home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Source / winterp-1.13 / src-server / wc_Text.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-04  |  78.9 KB  |  2,288 lines
  1. /* -*-C-*-
  2. ********************************************************************************
  3. *
  4. * File:         wc_Text.c
  5. * RCS:          $Header: wc_Text.c,v 1.6 91/03/14 03:15:19 mayer Exp $
  6. * Description:  XM_TEXT_WIDGET_CLASS
  7. * Author:       Niels Mayer, HPLabs
  8. * Created:      Sat Oct 28 04:50:44 1989
  9. * Modified:     Thu Oct  3 23:41:25 1991 (Niels Mayer) mayer@hplnpm
  10. * Language:     C
  11. * Package:      N/A
  12. * Status:       X11r5 contrib tape release
  13. *
  14. * WINTERP Copyright 1989, 1990, 1991 Hewlett-Packard Company (by Niels Mayer).
  15. * XLISP version 2.1, Copyright (c) 1989, by David Betz.
  16. *
  17. * Permission to use, copy, modify, distribute, and sell this software and its
  18. * documentation for any purpose is hereby granted without fee, provided that
  19. * the above copyright notice appear in all copies and that both that
  20. * copyright notice and this permission notice appear in supporting
  21. * documentation, and that the name of Hewlett-Packard and David Betz not be
  22. * used in advertising or publicity pertaining to distribution of the software
  23. * without specific, written prior permission.  Hewlett-Packard and David Betz
  24. * make no representations about the suitability of this software for any
  25. * purpose. It is provided "as is" without express or implied warranty.
  26. *
  27. * HEWLETT-PACKARD AND DAVID BETZ DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  28. * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
  29. * IN NO EVENT SHALL HEWLETT-PACKARD NOR DAVID BETZ BE LIABLE FOR ANY SPECIAL,
  30. * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  31. * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  32. * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  33. * PERFORMANCE OF THIS SOFTWARE.
  34. *
  35. * See ./winterp/COPYRIGHT for information on contacting the authors.
  36. * 
  37. * Please send modifications, improvements and bugfixes to mayer@hplabs.hp.com
  38. * Post XLISP-specific questions/information to the newsgroup comp.lang.lisp.x
  39. *
  40. ********************************************************************************
  41. */
  42. static char rcs_identity[] = "@(#)$Header: wc_Text.c,v 1.6 91/03/14 03:15:19 mayer Exp $";
  43.  
  44. /*
  45.  * <limits.h> defines machine dependent limits on sizes of numbers, if your
  46.  * machine doesn't have this, then your compiler doesn't conform to standards
  47.  * XPG2, XPG3, POSIX.1, FIPS 151-1 and you should complain to the manufacturer.
  48.  * 
  49.  * If for some reason your system isn't standards-conforming, you may work
  50.  * around this problem by using the following definitions (assuming 32 bit machine):
  51.  * 
  52.  * #define INT_MAX 2147483647
  53.  * #define INT_MIN (-2147483647 - 1)
  54.  */
  55. #include <limits.h>
  56. #include <stdio.h>
  57. #include <Xm/Xm.h>
  58.  
  59. #include "winterp.h"        /* this must occur before doing "#ifdef WINTERP_MOTIF_11" */
  60.  
  61. #include <Xm/Text.h>
  62. #ifdef WINTERP_MOTIF_11
  63. #include <Xm/TextF.h>
  64. #endif                /* WINTERP_MOTIF_11 */
  65.  
  66. #include "user_prefs.h"
  67. #include "xlisp/xlisp.h"
  68. #include "w_funtab.h"
  69.  
  70.  
  71. extern Widget Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(); /* w_classes.c */
  72.  
  73.  
  74. /******************************************************************************/
  75. static XmTextPosition Get_XmTextPosition_Argument()
  76. {
  77.   LVAL lval_position;
  78.   long position;
  79.  
  80.   lval_position = xlgafixnum();
  81.   position = (long) getfixnum(lval_position);
  82.   if (position < 0L)
  83.     xlerror("XmTextPosition must be a positive FIXNUM.", lval_position);
  84.   return ((XmTextPosition) position);
  85. }
  86.  
  87. /******************************************************************************/
  88. static int Get_Int_Argument(min, max)
  89.      long min;
  90.      long max;
  91. {
  92.   LVAL lval_num;
  93.   long num;
  94.  
  95.   lval_num = xlgafixnum();
  96.   num = (long) getfixnum(lval_num);
  97.   if (num < min)
  98.     xlerror("FIXNUM value too small.", lval_num);
  99.   if (num > max)
  100.     xlerror("FIXNUM value too large.", lval_num);
  101.   return ((int) num);
  102. }
  103.  
  104. /******************************************************************************/
  105. static Time Get_Optional_XEvent_Argument_Returning_EventTime_Else_CurrentTime()
  106. {
  107.   XEvent *event;
  108.  
  109.   if (moreargs()) {
  110.  
  111.     event = get_xevent(xlga_xevent());
  112.  
  113.     switch (event->type) {    /* better safe than sorry -- don't know what kind of XEvent will get passed... */
  114.     case KeyPress:
  115.     case KeyRelease:
  116.       return (event->xkey.time);
  117.       break;
  118.     case ButtonPress:
  119.     case ButtonRelease:
  120.       return (event->xbutton.time);
  121.       break;
  122.     case MotionNotify:
  123.       return (event->xmotion.time);
  124.       break;
  125.     case EnterNotify:
  126.     case LeaveNotify:
  127.       return (event->xcrossing.time);
  128.       break;
  129.     case PropertyNotify:
  130.       return (event->xproperty.time);
  131.       break;
  132.     case SelectionClear:
  133.       return (event->xselectionclear.time);
  134.       break;
  135.     case SelectionRequest:
  136.       return (event->xselectionrequest.time);
  137.       break;
  138.     case SelectionNotify:
  139.       return (event->xselection.time);
  140.       break;
  141.     default:
  142.       xlfail("Invalid XEvent kind passed to XmText/XmTextField function -- missing <time> slot.");
  143.       break;
  144.     }
  145.   }
  146.   else
  147. #ifdef WINTERP_MOTIF_11
  148.     {
  149.       extern Display* display;    /* global in winterp.c */
  150.       return (XtLastTimestampProcessed(display));
  151.     }
  152. #else
  153.     return (CurrentTime);
  154. #endif                /* WINTERP_MOTIF_11 */
  155. }
  156.  
  157. /*****************************************************************************
  158.  * (send XM_TEXT_WIDGET_CLASS :new 
  159.  *                           [:managed/:unmanaged]
  160.  *                           [:scrolled]
  161.  *                           [<name>]
  162.  *                           <parent> 
  163.  *                           [:XMN_<arg1> <val1>]
  164.  *                           [. . .             ]
  165.  *                           [:XMN_<argN> <valN>])
  166.  *
  167.  * The optional keyword submessage :managed will cause a subsequent call
  168.  * to XtManageChild(). If the submessage :unmanaged is present, or no
  169.  * submessage, then XtManageChild() won't be called, and the resulting
  170.  * widget will be returned unmanaged.
  171.  *
  172.  *  (send XM_TEXT_WIDGET_CLASS :new ...)
  173.  *  --> XmCreateText();
  174.  *  (send XM_TEXT_WIDGET_CLASS :new :scrolled ...)
  175.  *  --> XmCreateScrolledText();
  176.  ****************************************************************************/
  177. LVAL Xm_Text_Widget_Class_Method_ISNEW()
  178. {
  179.   extern ArgList Wres_Get_LispArglist(); /* from w_resources.c */
  180.   extern void    Wres_Free_C_Arglist_Data(); /* from w_resources.c */
  181.   extern LVAL k_managed, k_unmanaged, k_scrolled;
  182.   LVAL self, o_parent;
  183.   char* name;
  184.   Boolean managed_p, scrolled_p;
  185.   Widget parent_widget_id, widget_id;
  186.  
  187.   self = xlgaobject();        /* NOTE: xlobj.c:clnew() returns an OBJECT; if this method
  188.                    returns successfully, it will return a WIDGETOBJ */
  189.  
  190.   /* get optional managed/unmanaged arg */
  191.   if (moreargs() && ((*xlargv == k_managed) || (*xlargv == k_unmanaged)))
  192.     managed_p = (nextarg() == k_managed);
  193.   else
  194.     managed_p = FALSE;        /* by default don't call XtManageChild() */
  195.  
  196.   /* get optional :scrolled arg */
  197.   if (moreargs() && (*xlargv == k_scrolled)) {
  198.     nextarg();
  199.     scrolled_p = TRUE;
  200.   }
  201.   else
  202.     scrolled_p = FALSE;        /* by default, we don't want a scrolled editor */
  203.  
  204.   /* get optional <name> arg */
  205.   if (moreargs() && (stringp(*xlargv)))
  206.     name = (char*) getstring(nextarg());
  207.   else
  208.     name = "";            /* default name */
  209.  
  210.   /* get required <parent> widget-object arg */
  211.   parent_widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&o_parent);
  212.  
  213.   /*
  214.    * Store the widget object <self> in the XmNuserData resource on the
  215.    * widget. This will allow us to retrieve the widget object from Xtoolkit
  216.    * functions returning widget ID's without having to keep around a table
  217.    * of widgetID-->widget-objects.
  218.    */
  219.    ARGLIST_RESET(); ARGLIST_ADD(XmNuserData, (XtArgVal) self); 
  220.  
  221.   if (moreargs()) {        /* if there are more arguments, */
  222.     Cardinal xt_numargs;    /* then we have some extra widget resources to set */
  223.     ArgList xt_arglist = Wres_Get_LispArglist(self, parent_widget_id, ARGLIST(), &xt_numargs);
  224.     if (scrolled_p)
  225.       widget_id = XmCreateScrolledText(parent_widget_id, name, xt_arglist, xt_numargs);
  226.     else
  227.       widget_id = XmCreateText(parent_widget_id, name, xt_arglist, xt_numargs);
  228.     Wres_Free_C_Arglist_Data();
  229.   }
  230.   else 
  231.     if (scrolled_p)
  232.       widget_id = XmCreateScrolledText(parent_widget_id, name, ARGLIST());
  233.     else
  234.       widget_id = XmCreateText(parent_widget_id, name, ARGLIST());
  235.  
  236.   Wcls_Initialize_WIDGETOBJ(self, widget_id);
  237.  
  238.   if (managed_p)
  239.     XtManageChild(widget_id);
  240.  
  241. #ifdef DEBUG_WINTERP_1
  242.   Wcls_Print_WidgetObj_Info(self);
  243. #endif
  244.   return (self);
  245. }
  246.  
  247.  
  248. #ifdef WINTERP_MOTIF_11
  249. /*****************************************************************************
  250.  * (send <textdget> :PARENT)
  251.  *    ==> returns widgetobj
  252.  *
  253.  * This method is needed to work around a problem in Motif 1.1. It serves
  254.  * to override incorrect behavior when you call (send <listwidget> :PARENT)
  255.  * using the method defined on WIDGET_CLASS (List's super..class).
  256.  * 
  257.  * The problem was that :PARENT was returning the same widgetobj it was 
  258.  * given, but only in the case of a list/text widget created with the
  259.  * :scrolled option. Therefore, we check for this case, and if it occured
  260.  * we create a new widgetobj for the scrolled-window parent...
  261.  *
  262.  * Detailed analysis of problem: For each widgetobj created by winterp,
  263.  * we store the widgetobj on each  widgetID by doing
  264.  * XtSetValues(widgetid, XmNuserData<-->widgetobj).
  265.  * If the widget is a "hidden" child or parent of a widgetobj, then
  266.  * XmNuserData isn't set, so it defaults to NULL. When we retrieve a
  267.  * widgetID from the toolkit (as done when XtParent() is called) we then
  268.  * look at XmNuserData to lookup the associated widgetobj. If XmNuserData
  269.  * is NULL, then we create a new widgetobj of the appropriate class and
  270.  * initialize the widgetobj's widgetID...
  271.  * 
  272.  * The problem here results from the fact that XtGetValues(XmNuserData)
  273.  * on the parent widget returns the child's widgetobj. Since the
  274.  * parent widget is "hidden", we'd expect XmNuserData to be NULL.
  275.  * Instead, XmNuserData for the parent is set to the widgetobj of the
  276.  * child! This proc works around that problem...
  277.  *
  278.  * Note: see also w_libXt.c:Widget_Class_Method_PARENT(),
  279.  * wc_List.c:Xm_List_Widget_Class_Method_PARENT()
  280.  ****************************************************************************/
  281. LVAL Xm_Text_Widget_Class_Method_PARENT()
  282. {
  283.   extern LVAL Wcls_WidgetClassID_To_WIDGETCLASSOBJ(); /* w_classes.c */
  284.   extern LVAL Wcls_WidgetID_To_WIDGETOBJ();
  285.  
  286.   LVAL self, lval_parent;
  287.   Widget widget_id, parent_id;
  288.  
  289.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  290.   xllastarg();
  291.  
  292.   parent_id = XtParent(widget_id);
  293.   lval_parent = Wcls_WidgetID_To_WIDGETOBJ(parent_id);
  294.   
  295.   if (lval_parent != self)
  296.     return (lval_parent);
  297.   else {            /* handle motif 1.1 fuckup */
  298.     LVAL o_widgetclass;
  299.     if (o_widgetclass = Wcls_WidgetClassID_To_WIDGETCLASSOBJ(XtClass(parent_id))) /* returns NIL on failure */
  300.       /* (2): Create a new WIDGETOBJ of the appropriate class. */
  301.       lval_parent = newobject(o_widgetclass, WIDGETOBJ_SIZE);
  302.     else {            /* fail gracefully (i think). */
  303.       extern LVAL o_WIDGET_CLASS;    /* from wc_WIDGET.c */
  304.       errputstr("Warning -- In Wcls_WidgetID_To_WIDGETOBJ() couldn't find a valid\n");
  305.       errputstr("           widgetclass object inside widget classrecord. Creating\n");
  306.       errputstr("           a \"generic\" WIDGETOBJ of class WIDGET_CLASS.\n");
  307.       lval_parent = newobject(o_WIDGET_CLASS, WIDGETOBJ_SIZE);
  308.     }
  309.     Wcls_Initialize_WIDGETOBJ(lval_parent, parent_id);
  310.     
  311.     /* Store the pointer to the new widgetobj in the widget's XmNuserData resource. */
  312.     ARGLIST_RESET(); ARGLIST_ADD(XmNuserData, (XtArgVal) lval_parent);
  313.     XtSetValues(parent_id, ARGLIST());  
  314.     return (lval_parent);
  315.   }
  316. }
  317. #endif                /* WINTERP_MOTIF_11 */
  318.  
  319.  
  320.  
  321. /******************************************************************************
  322.  * typedef struct {
  323.  *     char *ptr;               -- Pointer to data.
  324.  *     int length;              -- Number of bytes of data.
  325.  *     XmTextFormat format;     -- Representation format.
  326.  * } XmTextBlockRec, *XmTextBlock;
  327.  * 
  328.  * typedef struct
  329.  * {
  330.  *     int reason;
  331.  *     XEvent  *event;
  332.  *     Boolean doit;
  333.  *     long currInsert, newInsert;
  334.  *     long startPos, endPos;
  335.  *     XmTextBlock text;
  336.  * } XmTextVerifyCallbackStruct, *XmTextVerifyPtr;
  337.  *
  338.  * Note that the text callbacks are "weird" in that they expect values in
  339.  * the callback structure to be set inside the callback proc to determine
  340.  * what actions need to be taken after the callbackproc returns. In
  341.  * particular, the XmTextVerifyCallbackStruct's 'doit' slot is always set to True,
  342.  * and must be set to False if the callbackproc doesn't want the action to be
  343.  * taken. To do this, Set_Call_Data_For_XmTextVerifyCallbackStruct() is
  344.  * called by Wcb_Meta_Callbackproc() after the callback lisp code is evaluated,
  345.  * and the values bound to these settable variables are set inside call_data....
  346.  * 
  347.  * Another inconsistency with the Text widget is that some callbacks on this widget
  348.  * return XmAnyCallbackStruct's (XmNactivateCallback, XmNfocusCallback,
  349.  * XmNvalueChangedCallback), whereas XmNlosingFocusCallback, XmNmodifyVerifyCallback,
  350.  * and XmNmotionVerifyCallback return XmTextVerifyCallbackStruct. In the code below,
  351.  * we look at the 'reason' slot of the call data, (which is present in both XmAnyCallbackStruct
  352.  * and in XmTextVerifyCallbackStruct) to determine the kind of callback that occured
  353.  * and we only bind the values that are appropriate for that kind  of callback.
  354.  * Information about which slots are valid for particular callback was taken from
  355.  * the documentation on the XmText(3X) widget, and verified against the Motif 1.1
  356.  * source -- this is valid for both XmText and XmTextField widgets...
  357.  ******************************************************************************/
  358. static LVAL s_CALLBACK_DOIT, s_CALLBACK_CUR_INSERT, s_CALLBACK_NEW_INSERT, s_CALLBACK_START_POS, s_CALLBACK_END_POS, s_CALLBACK_TEXT;
  359. static void Lexical_Bindings_For_XmTextVerifyCallbackStruct(bindings_list, lexical_env, cd, o_widget)
  360.      LVAL bindings_list;    /* a list of symbols to which values from XmTextVerifyCallbackStruct are bound */
  361.      LVAL lexical_env;        
  362.      XmTextVerifyCallbackStruct* cd;
  363.      LVAL o_widget;        /* XLTYPE_WIDGETOBJ */
  364. {
  365.   extern LVAL s_CALLBACK_WIDGET, s_CALLBACK_REASON, s_CALLBACK_XEVENT; /* w_callbacks.c */
  366.   extern LVAL Wcb_Get_Callback_Reason_Symbol();    /* w_callbacks.c */
  367.   extern LVAL true;
  368.   register LVAL s_bindname;
  369.  
  370.   switch (cd->reason) {
  371.  
  372.   case XmCR_LOSING_FOCUS:    /* valid XmTextVerifyCallbackStruct fields: reason, event, doit, currInsert, newInsert, startPos, endPos */
  373.  
  374.     for ( ; consp(bindings_list); bindings_list = cdr(bindings_list)) {
  375.       s_bindname = car(bindings_list);
  376.     
  377.       if (s_bindname == s_CALLBACK_WIDGET) {
  378.     xlpbind(s_bindname, o_widget, lexical_env);
  379.       }
  380.       else if (s_bindname == s_CALLBACK_REASON) {
  381.     xlpbind(s_bindname, Wcb_Get_Callback_Reason_Symbol(cd->reason), lexical_env);
  382.       }
  383.       else if (s_bindname == s_CALLBACK_XEVENT) {
  384.     xlpbind(s_bindname, (cd->event) ? cv_xevent(cd->event) : NIL, lexical_env);
  385.       }
  386.       else if (s_bindname == s_CALLBACK_DOIT) {
  387.     xlpbind(s_bindname, true, lexical_env);    /* this value is to be set within the callback code, we just make space for it, bind to T */
  388.       }
  389.       else if (s_bindname == s_CALLBACK_CUR_INSERT) {
  390.     xlpbind(s_bindname, cvfixnum((FIXTYPE) cd->currInsert), lexical_env);
  391.       }
  392.       else if (s_bindname == s_CALLBACK_NEW_INSERT) {
  393.     xlpbind(s_bindname, cvfixnum((FIXTYPE) cd->newInsert), lexical_env);
  394.       }
  395.       else if (s_bindname == s_CALLBACK_START_POS) {
  396.     xlpbind(s_bindname, cvfixnum((FIXTYPE) cd->startPos), lexical_env);
  397.       }
  398.       else if (s_bindname == s_CALLBACK_END_POS) {
  399.     xlpbind(s_bindname, cvfixnum((FIXTYPE) cd->endPos), lexical_env);
  400.       }
  401.       else {
  402.     extern char temptext[];    /* from winterp.c */
  403.     sprintf(temptext,
  404.         "Unknown binding name in XmTextVerifyCallbackStruct callback evaluator for\n\tCALLBACK_REASON == CR_LOSING_FOCUS.\n\tValid symbols are [%s %s %s %s %s %s %s %s].",
  405.         (char*) getstring(getpname(s_CALLBACK_WIDGET)),
  406.         (char*) getstring(getpname(s_CALLBACK_REASON)),
  407.         (char*) getstring(getpname(s_CALLBACK_XEVENT)),
  408.         (char*) getstring(getpname(s_CALLBACK_DOIT)),
  409.         (char*) getstring(getpname(s_CALLBACK_CUR_INSERT)),
  410.         (char*) getstring(getpname(s_CALLBACK_NEW_INSERT)),
  411.         (char*) getstring(getpname(s_CALLBACK_START_POS)),
  412.         (char*) getstring(getpname(s_CALLBACK_END_POS)));
  413.     xlerror(temptext, s_bindname);
  414.       }
  415.     }
  416.     break;
  417.  
  418.   case XmCR_MODIFYING_TEXT_VALUE: /* valid XmTextVerifyCallbackStruct fields: reason, event, doit, currInsert, newInsert, text, startPos, endPos */
  419.  
  420.     for ( ; consp(bindings_list); bindings_list = cdr(bindings_list)) {
  421.       s_bindname = car(bindings_list);
  422.  
  423.       if (s_bindname == s_CALLBACK_WIDGET) {
  424.     xlpbind(s_bindname, o_widget, lexical_env);
  425.       }
  426.       else if (s_bindname == s_CALLBACK_REASON) {
  427.     xlpbind(s_bindname, Wcb_Get_Callback_Reason_Symbol(cd->reason), lexical_env);
  428.       }
  429.       else if (s_bindname == s_CALLBACK_XEVENT) {
  430.     xlpbind(s_bindname, (cd->event) ? cv_xevent(cd->event) : NIL, lexical_env);
  431.       }
  432.       else if (s_bindname == s_CALLBACK_DOIT) {
  433.     xlpbind(s_bindname, true, lexical_env);    /* this value is to be set within the callback code, we just make space for it, bind to T */
  434.       }
  435.       else if (s_bindname == s_CALLBACK_CUR_INSERT) {
  436.     xlpbind(s_bindname, cvfixnum((FIXTYPE) cd->currInsert), lexical_env);
  437.       }
  438.       else if (s_bindname == s_CALLBACK_NEW_INSERT) {
  439.     xlpbind(s_bindname, cvfixnum((FIXTYPE) cd->newInsert), lexical_env);
  440.       }
  441.       else if (s_bindname == s_CALLBACK_START_POS) {
  442.     xlpbind(s_bindname, cvfixnum((FIXTYPE) cd->startPos), lexical_env);
  443.       }
  444.       else if (s_bindname == s_CALLBACK_END_POS) {
  445.     xlpbind(s_bindname, cvfixnum((FIXTYPE) cd->endPos), lexical_env);
  446.       }
  447.       else if (s_bindname == s_CALLBACK_TEXT) {
  448.     /* INTERNATIONALIZATION-LIMITATION: currently, we ignore the format field of XmTextBlockRec */
  449.     XmTextBlock textblockptr = cd->text;
  450.     if (textblockptr) {
  451.       LVAL lval_string;
  452.       char* string;
  453.       xlpbind(s_bindname, (lval_string = newstring(textblockptr->length + 1)), lexical_env);
  454.       string = (char*) getstring(lval_string);
  455.       strncpy(string, textblockptr->ptr, textblockptr->length);
  456.       string[textblockptr->length] = '\0';
  457.     }
  458.     else 
  459.       xlpbind(s_bindname, NIL, lexical_env);
  460.       }
  461.       else {
  462.     extern char temptext[];    /* from winterp.c */
  463.     sprintf(temptext,
  464.         "Unknown binding name in XmTextVerifyCallbackStruct callback evaluator for\n\tCALLBACK_REASON == XmCR_MODIFYING_TEXT_VALUE.\n\tValid symbols are [%s %s %s %s %s %s %s %s %s].",
  465.         (char*) getstring(getpname(s_CALLBACK_WIDGET)),
  466.         (char*) getstring(getpname(s_CALLBACK_REASON)),
  467.         (char*) getstring(getpname(s_CALLBACK_XEVENT)),
  468.         (char*) getstring(getpname(s_CALLBACK_DOIT)),
  469.         (char*) getstring(getpname(s_CALLBACK_CUR_INSERT)),
  470.         (char*) getstring(getpname(s_CALLBACK_NEW_INSERT)),
  471.         (char*) getstring(getpname(s_CALLBACK_START_POS)),
  472.         (char*) getstring(getpname(s_CALLBACK_END_POS)),
  473.         (char*) getstring(getpname(s_CALLBACK_TEXT)));
  474.     xlerror(temptext, s_bindname);
  475.       }
  476.     }
  477.     break;
  478.  
  479.   case XmCR_MOVING_INSERT_CURSOR: /* valid XmTextVerifyCallbackStruct fields: reason, event, currInsert, newInsert, doit */
  480.  
  481.     for ( ; consp(bindings_list); bindings_list = cdr(bindings_list)) {
  482.       s_bindname = car(bindings_list);
  483.  
  484.       if (s_bindname == s_CALLBACK_WIDGET) {
  485.     xlpbind(s_bindname, o_widget, lexical_env);
  486.       }
  487.       else if (s_bindname == s_CALLBACK_REASON) {
  488.     xlpbind(s_bindname, Wcb_Get_Callback_Reason_Symbol(cd->reason), lexical_env);
  489.       }
  490.       else if (s_bindname == s_CALLBACK_XEVENT) {
  491.     xlpbind(s_bindname, (cd->event) ? cv_xevent(cd->event) : NIL, lexical_env);
  492.       }
  493.       else if (s_bindname == s_CALLBACK_DOIT) {
  494.     xlpbind(s_bindname, true, lexical_env);    /* this value is to be set within the callback code, we just make space for it, bind to T */
  495.       }
  496.       else if (s_bindname == s_CALLBACK_CUR_INSERT) {
  497.     xlpbind(s_bindname, cvfixnum((FIXTYPE) cd->currInsert), lexical_env);
  498.       }
  499.       else if (s_bindname == s_CALLBACK_NEW_INSERT) {
  500.     xlpbind(s_bindname, cvfixnum((FIXTYPE) cd->newInsert), lexical_env);
  501.       }
  502.       else {
  503.     extern char temptext[];    /* from winterp.c */
  504.     sprintf(temptext,
  505.         "Unknown binding name in XmTextVerifyCallbackStruct callback evaluator for\n\tCALLBACK_REASON == CR_MOVING_INSERT_CURSOR.\n\t Valid symbols are [%s %s %s %s %s %s].",
  506.         (char*) getstring(getpname(s_CALLBACK_WIDGET)),
  507.         (char*) getstring(getpname(s_CALLBACK_REASON)),
  508.         (char*) getstring(getpname(s_CALLBACK_XEVENT)),
  509.         (char*) getstring(getpname(s_CALLBACK_DOIT)),
  510.         (char*) getstring(getpname(s_CALLBACK_CUR_INSERT)),
  511.         (char*) getstring(getpname(s_CALLBACK_NEW_INSERT)));
  512.     xlerror(temptext, s_bindname);
  513.       }
  514.     }
  515.     break;
  516.  
  517.   default:            /* valid call_data fields are from XmAnyCallbackStruct */
  518.  
  519.     for ( ; consp(bindings_list); bindings_list = cdr(bindings_list)) {
  520.       s_bindname = car(bindings_list);
  521.  
  522.       if (s_bindname == s_CALLBACK_WIDGET) {
  523.     xlpbind(s_bindname, o_widget, lexical_env);
  524.       }
  525.       else if (s_bindname == s_CALLBACK_REASON) {
  526.     xlpbind(s_bindname, Wcb_Get_Callback_Reason_Symbol(((XmAnyCallbackStruct*) cd)->reason), lexical_env);
  527.       }
  528.       else if (s_bindname == s_CALLBACK_XEVENT) {
  529.     xlpbind(s_bindname, (cd->event) ? cv_xevent(((XmAnyCallbackStruct*) cd)->event) : NIL, lexical_env);
  530.       }
  531.       else {
  532.     extern char temptext[];    /* from winterp.c */
  533.     sprintf(temptext,
  534.         "Unknown binding name in XmText's XmAnyCallbackStruct callback evaluator. Valid symbols are [%s %s %s].",
  535.         (char*) getstring(getpname(s_CALLBACK_WIDGET)),
  536.         (char*) getstring(getpname(s_CALLBACK_REASON)),
  537.         (char*) getstring(getpname(s_CALLBACK_XEVENT)));
  538.     xlerror(temptext, s_bindname);
  539.       }
  540.     }
  541.     break;
  542.   }
  543. }
  544.  
  545.  
  546. /******************************************************************************
  547.  * As far as I can tell, the only settable field in the Text widget's call_data
  548.  * is the doit field. Of course, the documentation and the source are quite
  549.  * cryptic about this!
  550.  ******************************************************************************/
  551. static void Set_Call_Data_For_XmTextVerifyCallbackStruct(bindings_list, lexical_env, cd)
  552.      LVAL bindings_list;    /* a list of symbols whose values are to be set in XmTextVerifyCallbackStruct */
  553.      LVAL lexical_env;        
  554.      XmTextVerifyCallbackStruct* cd;
  555. {
  556.   register LVAL ep = car(lexical_env); /* get current environment stack frame which was created in
  557.                       Wcb_Meta_Callbackproc() by Lexical_Bindings_For_XmTextVerifyCallbackStruct(). */
  558.   
  559.   for (; ep; ep = cdr(ep))    /* while there are more bindings in current environment */
  560.     if (s_CALLBACK_DOIT == car(car(ep))) { /* check to see if this symbol was bound in the envt */
  561.       cd->doit = (cdr(car(ep))) ? TRUE : FALSE;    /* set doit field if value is non-NIL */
  562.       return;
  563.     }
  564. }
  565.  
  566.  
  567. /******************************************************************************
  568.  * This is called indirectly via XtAddCallback() for callbacks returning
  569.  * an XmTextVerifyCallbackStruct as call_data.
  570.  ******************************************************************************/
  571. static void XmTextVerifyCallbackStruct_Callbackproc(widget, client_data, call_data)
  572.      Widget    widget;
  573.      XtPointer client_data;
  574.      XtPointer call_data;
  575. {
  576.   extern void Wcb_Meta_Callbackproc(); /* w_callbacks.c */
  577.  
  578.   Wcb_Meta_Callbackproc(client_data, call_data,
  579.             Lexical_Bindings_For_XmTextVerifyCallbackStruct,
  580.             Set_Call_Data_For_XmTextVerifyCallbackStruct);
  581. }
  582.  
  583.  
  584. /******************************************************************************
  585.  * Same as WIDGET_CLASS's :add_callback method except that this understands
  586.  * how to get values from the XmTextVerifyCallbackStruct.
  587.  ******************************************************************************/
  588. LVAL Xm_Text_Widget_Class_Method_ADD_CALLBACK()
  589. {
  590.   extern LVAL Wcb_Meta_Method_Add_Callback(); /* w_callbacks.c */
  591.  
  592.   return (Wcb_Meta_Method_Add_Callback(XmTextVerifyCallbackStruct_Callbackproc, FALSE));
  593. }
  594.  
  595.  
  596. /******************************************************************************
  597.  * Same as WIDGET_CLASS's :set_callback method except that this understands
  598.  * how to get values from the XmTextVerifyCallbackStruct.
  599.  ******************************************************************************/
  600. LVAL Xm_Text_Widget_Class_Method_SET_CALLBACK()
  601. {
  602.   extern LVAL Wcb_Meta_Method_Add_Callback(); /* w_callbacks.c */
  603.  
  604.   return (Wcb_Meta_Method_Add_Callback(XmTextVerifyCallbackStruct_Callbackproc, TRUE));
  605. }
  606.  
  607. #ifdef WINTERP_MOTIF_11
  608. /*****************************************************************************
  609.  * (send <text_widget> :SET_HIGHLIGHT <leftpos> <rightpos> <highlightmode>)
  610.  *   --> <text_widget>
  611.  *
  612.  * void XmTextSetHighlight (Widget w, XmTextPosition left, XmTextPosition right, XmHighlightMode mode);
  613.  * void XmTextFieldSetHighlight (Widget widget, XmTextPosition left, XmTextPosition right, XmHighlightMode mode);
  614.  ****************************************************************************/
  615. static LVAL s_HIGHLIGHT_NORMAL, s_HIGHLIGHT_SELECTED, s_HIGHLIGHT_SECONDARY_SELECTED;
  616. LVAL Xm_Text_Widget_Class_Method_SET_HIGHLIGHT()
  617. {
  618.   LVAL self, lval_mode;
  619.   XmTextPosition left, right;
  620.   XmHighlightMode mode;
  621.   Widget widget_id;
  622.  
  623.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  624.   left = Get_XmTextPosition_Argument();
  625.   right = Get_XmTextPosition_Argument();
  626.   lval_mode = xlgetarg();
  627.   xllastarg();
  628.  
  629.   if (lval_mode == s_HIGHLIGHT_NORMAL)
  630.     mode = XmHIGHLIGHT_NORMAL;
  631.   else if (lval_mode == s_HIGHLIGHT_SELECTED)
  632.     mode = XmHIGHLIGHT_SELECTED;
  633.   else if (lval_mode == s_HIGHLIGHT_SECONDARY_SELECTED)
  634.     mode = XmHIGHLIGHT_SECONDARY_SELECTED;
  635.   else {
  636.     extern char temptext[];    /* from winterp.c */
  637.     sprintf(temptext,
  638.         "Invalid XmHighlightMode argument. Expected one of the following [%s %s %s].",
  639.         (char*) getstring(getpname(s_HIGHLIGHT_NORMAL)),
  640.         (char*) getstring(getpname(s_HIGHLIGHT_SELECTED)),
  641.         (char*) getstring(getpname(s_HIGHLIGHT_SECONDARY_SELECTED)));
  642.     xlerror(temptext, lval_mode);
  643.   }
  644.   
  645.   XmTextSetHighlight(widget_id, left, right, mode);
  646.  
  647.   return (self);
  648. }
  649.  
  650. LVAL Xm_Text_Field_Widget_Class_Method_SET_HIGHLIGHT()
  651. {
  652.   LVAL self, lval_mode;
  653.   XmTextPosition left, right;
  654.   XmHighlightMode mode;
  655.   Widget widget_id;
  656.  
  657.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  658.   left = Get_XmTextPosition_Argument();
  659.   right = Get_XmTextPosition_Argument();
  660.   lval_mode = xlgetarg();
  661.   xllastarg();
  662.  
  663.   if (lval_mode == s_HIGHLIGHT_NORMAL)
  664.     mode = XmHIGHLIGHT_NORMAL;
  665.   else if (lval_mode == s_HIGHLIGHT_SELECTED)
  666.     mode = XmHIGHLIGHT_SELECTED;
  667.   else if (lval_mode == s_HIGHLIGHT_SECONDARY_SELECTED)
  668.     mode = XmHIGHLIGHT_SECONDARY_SELECTED;
  669.   else {
  670.     extern char temptext[];    /* from winterp.c */
  671.     sprintf(temptext,
  672.         "Invalid XmHighlightMode argument. Expected one of the following [%s %s %s].",
  673.         (char*) getstring(getpname(s_HIGHLIGHT_NORMAL)),
  674.         (char*) getstring(getpname(s_HIGHLIGHT_SELECTED)),
  675.         (char*) getstring(getpname(s_HIGHLIGHT_SECONDARY_SELECTED)));
  676.     xlerror(temptext, lval_mode);
  677.   }
  678.   
  679.   XmTextFieldSetHighlight(widget_id, left, right, mode);
  680.  
  681.   return (self);
  682. }
  683. #endif                /* WINTERP_MOTIF_11 */
  684.  
  685.  
  686. /*****************************************************************************
  687.  * (send <text_widget> :GET_STRING)
  688.  *   --> string displayed by the text edit widget
  689.  *
  690.  * char *XmTextGetString (Widget widget);
  691.  * char *XmTextFieldGetString (Widget widget);
  692.  ****************************************************************************/
  693. LVAL Xm_Text_Widget_Class_Method_GET_STRING()
  694. {
  695.   LVAL self, s_result;
  696.   char* string;
  697.   Widget widget_id;
  698.  
  699.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  700.   xllastarg();
  701.  
  702.   if (string = XmTextGetString(widget_id)) {
  703. /*
  704.     s_result = cvstring(string);
  705.     XtFree(string);
  706. */
  707.     s_result = cv_string(string); /* XmTextGetString() result is not copied, will be freed by XLISP-GC */
  708.   }
  709.   else 
  710.     s_result = cvstring("");    /* don't call cv_string on this because GC would end up doing XtFree("")... */
  711.  
  712.   return (s_result);
  713. }
  714.  
  715. #ifdef WINTERP_MOTIF_11
  716. LVAL Xm_Text_Field_Widget_Class_Method_GET_STRING()
  717. {
  718.   LVAL self, s_result;
  719.   char* string;
  720.   Widget widget_id;
  721.  
  722.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  723.   xllastarg();
  724.  
  725.   if (string = XmTextFieldGetString(widget_id)) {
  726. /*
  727.     s_result = cvstring(string);
  728.     XtFree(string);
  729. */
  730.     s_result = cv_string(string); /* XmTextFieldGetString() result is not copied, will be freed by XLISP-GC */
  731.   }
  732.   else 
  733.     s_result = cvstring("");    /* don't call cv_string on this because GC would end up doing XtFree("")... */
  734.  
  735.   return (s_result);
  736. }
  737. #endif                /* WINTERP_MOTIF_11 */
  738.  
  739.  
  740. /*****************************************************************************
  741.  * (send <text_widget> :GET_LAST_POSITION)
  742.  * --> integer representing last position
  743.  *
  744.  * XmTextPosition XmTextGetLastPosition (Widget widget);
  745.  * XmTextPosition XmTextFieldGetLastPosition (Widget widget);
  746.  ****************************************************************************/
  747. LVAL Xm_Text_Widget_Class_Method_GET_LAST_POSITION()
  748. {
  749.   LVAL self;
  750.   Widget widget_id;
  751.  
  752.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  753.   xllastarg();
  754.  
  755. #if (defined(WINTERP_MOTIF_11) || defined(hpux))
  756.   return (cvfixnum((FIXTYPE) XmTextGetLastPosition(widget_id)));
  757. #else
  758.   /*
  759.    * In HPUX 7.0's Motif 1.0, XmTextGetLastPosition() is defined... however
  760.    * other manufacturers libXm (e.g. IBM AIX 3.1) don't export XmTextGetLastPosition().
  761.    * In order to make WINTERP compile with the unknown Motif 1.0 libXm's "out there,
  762.    * I've decided to only allow Motif 1.0 access to XmTextGetLastPosition() from HPUX.
  763.    * If your Motif 1.0 dist supports this, then make sure the above #if expression becomes true.
  764.    */
  765.   xlfail("XmTextGetLastPosition() may not be defined on non-HPUX Motif 1.0.\nIf you know that it exists in your Motif installation, and you need to use\nthis method, you should recompile winterp after modifying src-server/wc_Text.c.");
  766.   return (NIL);
  767. #endif
  768. }
  769.  
  770. #ifdef WINTERP_MOTIF_11
  771. LVAL Xm_Text_Field_Widget_Class_Method_GET_LAST_POSITION()
  772. {
  773.   LVAL self;
  774.   Widget widget_id;
  775.  
  776.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  777.   xllastarg();
  778.  
  779.   return (cvfixnum((FIXTYPE) XmTextFieldGetLastPosition(widget_id)));
  780. }
  781. #endif                /* WINTERP_MOTIF_11 */
  782.  
  783.  
  784. /*****************************************************************************
  785.  * (send <text_widget> :SET_STRING <string>)
  786.  *
  787.  * void XmTextSetString (Widget widget, char *value);
  788.  * void XmTextFieldSetString (Widget widget, char *value);
  789.  ****************************************************************************/
  790. LVAL Xm_Text_Widget_Class_Method_SET_STRING()
  791. {
  792.   LVAL self;
  793.   char* string;
  794.   Widget widget_id;
  795.  
  796.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  797.   string = (char*) getstring(xlgastring());
  798.   xllastarg();
  799.  
  800.   XmTextSetString(widget_id, string);
  801.   return (self);
  802. }
  803.  
  804. #ifdef WINTERP_MOTIF_11
  805. LVAL Xm_Text_Field_Widget_Class_Method_SET_STRING()
  806. {
  807.   LVAL self;
  808.   char* string;
  809.   Widget widget_id;
  810.  
  811.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  812.   string = (char*) getstring(xlgastring());
  813.   xllastarg();
  814.  
  815.   XmTextFieldSetString(widget_id, string);
  816.   return (self);
  817. }
  818. #endif                /* WINTERP_MOTIF_11 */
  819.  
  820.  
  821. /*****************************************************************************
  822.  * (send <text_widget> :replace <from-pos> <to-pos> <string>)
  823.  *
  824.  * void XmTextReplace (Widget widget, XmTextPosition frompos, XmTextPosition topos, char *value);
  825.  * void XmTextFieldReplace (Widget widget, XmTextPosition from_pos, XmTextPosition to_pos, char *value);
  826.  ****************************************************************************/
  827. LVAL Xm_Text_Widget_Class_Method_REPLACE()
  828. {
  829.   LVAL self;
  830.   XmTextPosition frompos, topos;
  831.   char* string;
  832.   Widget widget_id;
  833.  
  834.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  835.   frompos = Get_XmTextPosition_Argument();
  836.   topos = Get_XmTextPosition_Argument();
  837.   string = (char*) getstring(xlgastring());
  838.   xllastarg();
  839.  
  840.   XmTextReplace(widget_id, frompos, topos, string);
  841.   return (self);
  842. }
  843.  
  844. #ifdef WINTERP_MOTIF_11
  845. LVAL Xm_Text_Field_Widget_Class_Method_REPLACE()
  846. {
  847.   LVAL self;
  848.   XmTextPosition frompos, topos;
  849.   char* string;
  850.   Widget widget_id;
  851.  
  852.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  853.   frompos = Get_XmTextPosition_Argument();
  854.   topos = Get_XmTextPosition_Argument();
  855.   string = (char*) getstring(xlgastring());
  856.   xllastarg();
  857.  
  858.   XmTextFieldReplace(widget_id, frompos, topos, string);
  859.   return (self);
  860. }
  861. #endif                /* WINTERP_MOTIF_11 */
  862.  
  863.  
  864. #ifdef WINTERP_MOTIF_11
  865. /*****************************************************************************
  866.  * (send <text_widget> :INSERT <position> <value>)
  867.  *   --> <text_widget>
  868.  *
  869.  * void XmTextInsert (Widget widget, XmTextPosition position, char *value);
  870.  * void XmTextFieldInsert (Widget widget, XmTextPosition position, char *value);
  871.  ****************************************************************************/
  872. LVAL Xm_Text_Widget_Class_Method_INSERT()
  873. {
  874.   LVAL self, lval_mode;
  875.   XmTextPosition position;
  876.   char* value;
  877.   Widget widget_id;
  878.  
  879.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  880.   position = Get_XmTextPosition_Argument();
  881.   value = (char*) getstring(xlgastring());
  882.   xllastarg();
  883.  
  884.   XmTextInsert(widget_id, position, value);
  885.  
  886.   return (self);
  887. }
  888.  
  889. LVAL Xm_Text_Field_Widget_Class_Method_INSERT()
  890. {
  891.   LVAL self, lval_mode;
  892.   XmTextPosition position;
  893.   char* value;
  894.   Widget widget_id;
  895.  
  896.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  897.   position = Get_XmTextPosition_Argument();
  898.   value = (char*) getstring(xlgastring());
  899.   xllastarg();
  900.  
  901.   XmTextFieldInsert(widget_id, position, value);
  902.  
  903.   return (self);
  904. }
  905. #endif                /* WINTERP_MOTIF_11 */
  906.  
  907.  
  908. #ifdef WINTERP_MOTIF_11
  909. /*****************************************************************************
  910.  * (send <text_widget> :SET_ADD_MODE <add-modeP>)
  911.  *
  912.  * void XmTextSetAddMode (Widget widget, Boolean state);
  913.  * void XmTextFieldSetAddMode (Widget widget, Boolean state);
  914.  ****************************************************************************/
  915. LVAL Xm_Text_Widget_Class_Method_SET_ADD_MODE()
  916. {
  917.   LVAL self, lval_addmodeP;
  918.   Widget widget_id;
  919.  
  920.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  921.   lval_addmodeP = xlgetarg();
  922.   xllastarg();
  923.  
  924.   XmTextSetAddMode(widget_id, (lval_addmodeP) ? TRUE : FALSE);
  925.  
  926.   return (self);
  927. }
  928.  
  929. LVAL Xm_Text_Field_Widget_Class_Method_SET_ADD_MODE()
  930. {
  931.   LVAL self, lval_addmodeP;
  932.   Widget widget_id;
  933.  
  934.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  935.   lval_addmodeP = xlgetarg();
  936.   xllastarg();
  937.  
  938.   XmTextFieldSetAddMode(widget_id, (lval_addmodeP) ? TRUE : FALSE);
  939.  
  940.   return (self);
  941. }
  942. #endif                /* WINTERP_MOTIF_11 */
  943.  
  944.  
  945. #ifdef WINTERP_MOTIF_11
  946. /*****************************************************************************
  947.  * (send <text_widget> :GET_ADD_MODE)
  948.  *      ====> returns T if in add mode, else NIL.
  949.  *
  950.  * Boolean XmTextGetAddMode (Widget widget);
  951.  & Boolean XmTextFieldGetAddMode (Widget widget);
  952.  ****************************************************************************/
  953. LVAL Xm_Text_Widget_Class_Method_GET_ADD_MODE()
  954. {
  955.   extern LVAL true;
  956.   LVAL self;
  957.   Widget widget_id;
  958.  
  959.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  960.   xllastarg();
  961.  
  962.   return (XmTextGetAddMode(widget_id) ? true : NIL);
  963. }
  964.  
  965. LVAL Xm_Text_Field_Widget_Class_Method_GET_ADD_MODE()
  966. {
  967.   extern LVAL true;
  968.   LVAL self;
  969.   Widget widget_id;
  970.  
  971.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  972.   xllastarg();
  973.  
  974.   return (XmTextFieldGetAddMode(widget_id) ? true : NIL);
  975. }
  976. #endif                /* WINTERP_MOTIF_11 */
  977.  
  978.  
  979. /*****************************************************************************
  980.  * (send <text_widget> :get_editable)
  981.  *      ====> returns T if editable, NIL otherwise.
  982.  *
  983.  * Boolean XmTextGetEditable (Widget widget);
  984.  * Boolean XmTextFieldGetEditable (Widget widget);
  985.  ****************************************************************************/
  986. LVAL Xm_Text_Widget_Class_Method_GET_EDITABLE()
  987. {
  988.   extern LVAL true;
  989.   LVAL self;
  990.   Widget widget_id;
  991.  
  992.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  993.   xllastarg();
  994.  
  995.   return (XmTextGetEditable(widget_id) ? true : NIL);
  996. }
  997.  
  998. #ifdef WINTERP_MOTIF_11
  999. LVAL Xm_Text_Field_Widget_Class_Method_GET_EDITABLE()
  1000. {
  1001.   extern LVAL true;
  1002.   LVAL self;
  1003.   Widget widget_id;
  1004.  
  1005.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1006.   xllastarg();
  1007.  
  1008.   return (XmTextFieldGetEditable(widget_id) ? true : NIL);
  1009. }
  1010. #endif                /* WINTERP_MOTIF_11 */
  1011.  
  1012.  
  1013. /*****************************************************************************
  1014.  * (send <text_widget> :set_editable <editableP>)
  1015.  *
  1016.  * void XmTextSetEditable (Widget widget, Boolean editable);
  1017.  * void XmTextFieldSetEditable (Widget widget, Boolean editable);
  1018.  ****************************************************************************/
  1019. LVAL Xm_Text_Widget_Class_Method_SET_EDITABLE()
  1020. {
  1021.   LVAL self, lval_editablep;
  1022.   Widget widget_id;
  1023.  
  1024.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1025.   lval_editablep = xlgetarg();
  1026.   xllastarg();
  1027.  
  1028.   XmTextSetEditable(widget_id, (lval_editablep) ? TRUE : FALSE);
  1029.   return (self);
  1030. }
  1031.  
  1032. #ifdef WINTERP_MOTIF_11
  1033. LVAL Xm_Text_Field_Widget_Class_Method_SET_EDITABLE()
  1034. {
  1035.   LVAL self, lval_editablep;
  1036.   Widget widget_id;
  1037.  
  1038.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1039.   lval_editablep = xlgetarg();
  1040.   xllastarg();
  1041.  
  1042.   XmTextFieldSetEditable(widget_id, (lval_editablep) ? TRUE : FALSE);
  1043.   return (self);
  1044. }
  1045. #endif                /* WINTERP_MOTIF_11 */
  1046.  
  1047.  
  1048. /*****************************************************************************
  1049.  * (send <text_widget> :GET_MAX_LENGTH)
  1050.  *       =====> FIXNUM, the maximum length of the Text widget.
  1051.  *
  1052.  * int XmTextGetMaxLength (Widget widget);
  1053.  * int XmTextFieldGetMaxLength (Widget widget);
  1054.  ****************************************************************************/
  1055. LVAL Xm_Text_Widget_Class_Method_GET_MAX_LENGTH()
  1056. {
  1057.   LVAL self, s_result;
  1058.   char* string;
  1059.   Widget widget_id;
  1060.  
  1061.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1062.   xllastarg();
  1063.  
  1064.   return (cvfixnum((FIXTYPE) XmTextGetMaxLength(widget_id)));
  1065. }
  1066.  
  1067. #ifdef WINTERP_MOTIF_11
  1068. LVAL Xm_Text_Field_Widget_Class_Method_GET_MAX_LENGTH()
  1069. {
  1070.   LVAL self, s_result;
  1071.   char* string;
  1072.   Widget widget_id;
  1073.  
  1074.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1075.   xllastarg();
  1076.  
  1077.   return (cvfixnum((FIXTYPE) XmTextFieldGetMaxLength(widget_id)));
  1078. }
  1079. #endif                /* WINTERP_MOTIF_11 */
  1080.  
  1081.  
  1082. /*****************************************************************************
  1083.  * (send <text_widget> :SET_MAX_LENGTH <max_length>)
  1084.  *
  1085.  * void XmTextSetMaxLength (Widget widget, int max_length);
  1086.  * void XmTextFieldSetMaxLength (Widget widget, int max_length);
  1087.  ****************************************************************************/
  1088. LVAL Xm_Text_Widget_Class_Method_SET_MAX_LENGTH()
  1089. {
  1090.   LVAL self;
  1091.   int max_length;
  1092.   Widget widget_id;
  1093.  
  1094.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1095.   max_length = Get_Int_Argument(0L, (long) INT_MAX);
  1096.   xllastarg();
  1097.  
  1098.   XmTextSetMaxLength(widget_id, max_length);
  1099.   return (self);
  1100. }
  1101.  
  1102. #ifdef WINTERP_MOTIF_11
  1103. LVAL Xm_Text_Field_Widget_Class_Method_SET_MAX_LENGTH()
  1104. {
  1105.   LVAL self;
  1106.   int max_length;
  1107.   Widget widget_id;
  1108.  
  1109.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1110.   max_length = Get_Int_Argument(0L, (long) INT_MAX);
  1111.   xllastarg();
  1112.  
  1113.   XmTextFieldSetMaxLength(widget_id, max_length);
  1114.   return (self);
  1115. }
  1116. #endif                /* WINTERP_MOTIF_11 */
  1117.  
  1118.  
  1119. #ifdef WINTERP_MOTIF_11
  1120. /*****************************************************************************
  1121.  * (send <text_widget> :REMOVE) -- deletes the primary selected text and calls the widget's XmNmodifyVerifyCallback and XmNvalueChangedCallback callbacks if there is a selection.
  1122.  *    ====> returns T normally; returns NIL if the primary selection is NULL
  1123.  *          or if the widget doesn't own the primary selection.
  1124.  *
  1125.  * Boolean XmTextRemove (Widget widget);
  1126.  * Boolean XmTextFieldRemove (Widget widget);
  1127.  ****************************************************************************/
  1128. LVAL Xm_Text_Widget_Class_Method_REMOVE()
  1129. {
  1130.   extern LVAL true;
  1131.   LVAL self;
  1132.   Widget widget_id;
  1133.  
  1134.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1135.   xllastarg();
  1136.  
  1137.   return (XmTextRemove(widget_id) ? true : NIL);
  1138. }
  1139.  
  1140. LVAL Xm_Text_Field_Widget_Class_Method_REMOVE()
  1141. {
  1142.   extern LVAL true;
  1143.   LVAL self;
  1144.   Widget widget_id;
  1145.  
  1146.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1147.   xllastarg();
  1148.  
  1149.   return (XmTextFieldRemove(widget_id) ? true : NIL);
  1150. }
  1151. #endif                /* WINTERP_MOTIF_11 */
  1152.  
  1153.  
  1154. #ifdef WINTERP_MOTIF_11
  1155. /*****************************************************************************
  1156.  * (send <text_widget> :COPY [<xevent>]) -- copies the primary selection to the clipboard
  1157.  *    =====> Returns T normally; returns NIL if the primary selection is NULL,
  1158.  *      if the widget doesn't own the primary selection, or if the function
  1159.  *      is unable to gain ownership of the clipboard selection.
  1160.  *
  1161.  * Note that the optional <xevent> argument is used to set the time of the
  1162.  * selection. Since the time value comes from the time slot on the XEvent
  1163.  * bound to the callback symbol CALLBACK_XEVENT, we just pass the <xevent>
  1164.  * generated by the callback...
  1165.  *
  1166.  * Boolean XmTextCopy (Widget widget, Time copy_time);
  1167.  * Boolean XmTextFieldCopy (Widget widget, Time clip_time);
  1168.  ****************************************************************************/
  1169. LVAL Xm_Text_Widget_Class_Method_COPY()
  1170. {
  1171.   extern LVAL true;
  1172.   LVAL self;
  1173.   Widget widget_id;
  1174.   Time time;
  1175.  
  1176.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1177.   time = Get_Optional_XEvent_Argument_Returning_EventTime_Else_CurrentTime();
  1178.   xllastarg();
  1179.  
  1180.   return (XmTextCopy(widget_id, time) ? true : NIL);
  1181. }
  1182.  
  1183. LVAL Xm_Text_Field_Widget_Class_Method_COPY()
  1184. {
  1185.   extern LVAL true;
  1186.   LVAL self;
  1187.   Widget widget_id;
  1188.   Time time;
  1189.  
  1190.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1191.   time = Get_Optional_XEvent_Argument_Returning_EventTime_Else_CurrentTime();
  1192.   xllastarg();
  1193.  
  1194.   return (XmTextFieldCopy(widget_id, time) ? true : NIL);
  1195. }
  1196. #endif                /* WINTERP_MOTIF_11 */
  1197.  
  1198.  
  1199. #ifdef WINTERP_MOTIF_11
  1200. /*****************************************************************************
  1201.  * (send <text_widget> :CUT [<xevent>]) -- copies the primary selected text to the clipboard and then deletes the primary selected text; also calls the widget's XmNmodifyVerifyCallback and XmNvalueChangedCallback callbacks.
  1202.  *    =====> Returns T normally; returns NIL if the primary selection is NULL,
  1203.  *      if the widget doesn't own the primary selection, or if the function
  1204.  *      is unable to gain ownership of the clipboard selection.
  1205.  *
  1206.  * Note that the optional <xevent> argument is used to set the time of the
  1207.  * selection. Since the time value comes from the time slot on the XEvent
  1208.  * bound to the callback symbol CALLBACK_XEVENT, we just pass the <xevent>
  1209.  * generated by the callback...
  1210.  *
  1211.  * Boolean XmTextCut (Widget widget, Time cut_time);
  1212.  * Boolean XmTextFieldCut (Widget widget, Time clip_time);
  1213.  ****************************************************************************/
  1214. LVAL Xm_Text_Widget_Class_Method_CUT()
  1215. {
  1216.   extern LVAL true;
  1217.   LVAL self;
  1218.   Widget widget_id;
  1219.   Time time;
  1220.  
  1221.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1222.   time = Get_Optional_XEvent_Argument_Returning_EventTime_Else_CurrentTime();
  1223.   xllastarg();
  1224.  
  1225.   return (XmTextCut(widget_id, time) ? true : NIL);
  1226. }
  1227.  
  1228. LVAL Xm_Text_Field_Widget_Class_Method_CUT()
  1229. {
  1230.   extern LVAL true;
  1231.   LVAL self;
  1232.   Widget widget_id;
  1233.   Time time;
  1234.  
  1235.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1236.   time = Get_Optional_XEvent_Argument_Returning_EventTime_Else_CurrentTime();
  1237.   xllastarg();
  1238.  
  1239.   return (XmTextFieldCut(widget_id, time) ? true : NIL);
  1240. }
  1241. #endif                /* WINTERP_MOTIF_11 */
  1242.  
  1243.  
  1244. #ifdef WINTERP_MOTIF_11
  1245. /*****************************************************************************
  1246.  * (send <text_widget> :PASTE) -- inserts the clipboard selection at the destination cursor. If XmNpendingDelete is True and the destination cursor is inside the current selection, the clipboard selection replaces the selected text. Also calls the widget's XmNmodifyVerifyCallback and XmNvalueChangedCallback callbacks...
  1247.  *    ====> returns T normally; returns NIL if the primary selection is NULL
  1248.  *          or if the widget doesn't own the primary selection.
  1249.  *
  1250.  * Boolean XmTextPaste (Widget widget);
  1251.  * Boolean XmTextFieldPaste (Widget widget);
  1252.  ****************************************************************************/
  1253. LVAL Xm_Text_Widget_Class_Method_PASTE()
  1254. {
  1255.   extern LVAL true;
  1256.   LVAL self;
  1257.   Widget widget_id;
  1258.  
  1259.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1260.   xllastarg();
  1261.  
  1262.   return (XmTextPaste(widget_id) ? true : NIL);
  1263. }
  1264.  
  1265. LVAL Xm_Text_Field_Widget_Class_Method_PASTE()
  1266. {
  1267.   extern LVAL true;
  1268.   LVAL self;
  1269.   Widget widget_id;
  1270.  
  1271.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1272.   xllastarg();
  1273.  
  1274.   return (XmTextFieldPaste(widget_id) ? true : NIL);
  1275. }
  1276. #endif                /* WINTERP_MOTIF_11 */
  1277.  
  1278.  
  1279. /*****************************************************************************
  1280.  * (send <text_widget> :GET_SELECTION)
  1281.  *       ===> returns a string, the selected text.
  1282.  *
  1283.  * char *XmTextGetSelection (Widget widget);
  1284.  * char *XmTextFieldGetSelection (Widget widget);
  1285.  ****************************************************************************/
  1286. LVAL Xm_Text_Widget_Class_Method_GET_SELECTION()
  1287. {
  1288.   LVAL self, s_result;
  1289.   char* string;
  1290.   Widget widget_id;
  1291.  
  1292.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1293.   xllastarg();
  1294.  
  1295.   if (string = XmTextGetSelection(widget_id)) {
  1296. /*
  1297.     s_result = cvstring(string);
  1298.     XtFree(string);
  1299. */
  1300.     s_result = cv_string(string); /* XmTextGetSelection() result is not copied, will be freed by XLISP-GC */
  1301.   }
  1302.   else
  1303.     s_result = cvstring("");    /* don't call cv_string on this because GC would end up doing XtFree("")... */
  1304.  
  1305.   return (s_result);
  1306. }
  1307.  
  1308. #ifdef WINTERP_MOTIF_11
  1309. LVAL Xm_Text_Field_Widget_Class_Method_GET_SELECTION()
  1310. {
  1311.   LVAL self, s_result;
  1312.   char* string;
  1313.   Widget widget_id;
  1314.  
  1315.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1316.   xllastarg();
  1317.  
  1318.   if (string = XmTextFieldGetSelection(widget_id)) {
  1319. /*
  1320.     s_result = cvstring(string);
  1321.     XtFree(string);
  1322. */
  1323.     s_result = cv_string(string); /* XmTextFieldGetSelection() result is not copied, will be freed by XLISP-GC */
  1324.   }
  1325.   else
  1326.     s_result = cvstring("");    /* don't call cv_string on this because GC would end up doing XtFree("")... */
  1327.  
  1328.   return (s_result);
  1329. }
  1330. #endif                /* WINTERP_MOTIF_11 */
  1331.  
  1332.  
  1333. /*****************************************************************************
  1334.  * (send <text_widget> :SET_SELECTION <firstpos> <lastpos> [<xevent>])
  1335.  * Note that the optional <xevent> argument is used to set the time of the
  1336.  * selection. Since the time value comes from the time slot on the XEvent
  1337.  * bound to the callback symbol CALLBACK_XEVENT, we just pass the <xevent>
  1338.  * generated by the callback...
  1339.  *
  1340.  * void XmTextSetSelection (Widget widget, XmTextPosition first, XmTextPosition last, Time set_time);
  1341.  * void XmTextFieldSetSelection (Widget widget, XmTextPosition first, XmTextPosition last, Time sel_time);
  1342.  ****************************************************************************/
  1343. LVAL Xm_Text_Widget_Class_Method_SET_SELECTION()
  1344. {
  1345.   LVAL self;
  1346.   XmTextPosition firstpos, lastpos;
  1347.   Widget widget_id;
  1348.   Time time;
  1349.  
  1350.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1351.   firstpos = Get_XmTextPosition_Argument();
  1352.   lastpos = Get_XmTextPosition_Argument();
  1353.   time = Get_Optional_XEvent_Argument_Returning_EventTime_Else_CurrentTime();
  1354.   xllastarg();
  1355.  
  1356.   XmTextSetSelection(widget_id, firstpos, lastpos, time); 
  1357.   return (self);
  1358. }
  1359.  
  1360. #ifdef WINTERP_MOTIF_11
  1361. LVAL Xm_Text_Field_Widget_Class_Method_SET_SELECTION()
  1362. {
  1363.   LVAL self;
  1364.   XmTextPosition firstpos, lastpos;
  1365.   Widget widget_id;
  1366.   Time time;
  1367.  
  1368.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1369.   firstpos = Get_XmTextPosition_Argument();
  1370.   lastpos = Get_XmTextPosition_Argument();
  1371.   time = Get_Optional_XEvent_Argument_Returning_EventTime_Else_CurrentTime();
  1372.   xllastarg();
  1373.  
  1374.   XmTextFieldSetSelection(widget_id, firstpos, lastpos, time);
  1375.   return (self);
  1376. }
  1377. #endif                /* WINTERP_MOTIF_11 */
  1378.  
  1379.  
  1380. /*****************************************************************************
  1381.  * (send <text_widget> :CLEAR_SELECTION [<xevent>])
  1382.  * Note that the optional <xevent> argument is used to set the time of the
  1383.  * selection. Since the time value comes from the time slot on the XEvent
  1384.  * bound to the callback symbol CALLBACK_XEVENT, we just pass the <xevent>
  1385.  * generated by the callback...
  1386.  *
  1387.  * void XmTextClearSelection (Widget widget, Time clear_time);
  1388.  * void XmTextFieldClearSelection (Widget widget, Time sel_time);
  1389.  ****************************************************************************/
  1390. LVAL Xm_Text_Widget_Class_Method_CLEAR_SELECTION()
  1391. {
  1392.   LVAL self;
  1393.   Widget widget_id;
  1394.   Time time;
  1395.  
  1396.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1397.   time = Get_Optional_XEvent_Argument_Returning_EventTime_Else_CurrentTime();
  1398.   xllastarg();
  1399.  
  1400.   XmTextClearSelection(widget_id, time);
  1401.  
  1402.   return (self);
  1403. }
  1404.  
  1405. #ifdef WINTERP_MOTIF_11
  1406. LVAL Xm_Text_Field_Widget_Class_Method_CLEAR_SELECTION()
  1407. {
  1408.   LVAL self;
  1409.   Widget widget_id;
  1410.   Time time;
  1411.  
  1412.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1413.   time = Get_Optional_XEvent_Argument_Returning_EventTime_Else_CurrentTime();
  1414.   xllastarg();
  1415.  
  1416.   XmTextFieldClearSelection(widget_id, time);
  1417.  
  1418.   return (self);
  1419. }
  1420. #endif                /* WINTERP_MOTIF_11 */
  1421.  
  1422.  
  1423. /*****************************************************************************
  1424.  * (send <text_widget> :GET_TOP_CHARACTER)
  1425.  *       ====> returns a FIXNUM representing top position of Text widget.
  1426.  *
  1427.  * Note that this method is on XmText only; missing from XmTextField
  1428.  * XmTextPosition XmTextGetTopCharacter (Widget widget);
  1429.  ****************************************************************************/
  1430. LVAL Xm_Text_Widget_Class_Method_GET_TOP_CHARACTER()
  1431. {
  1432.   LVAL self;
  1433.   Widget widget_id;
  1434.  
  1435.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1436.   xllastarg();
  1437.  
  1438. #ifndef WINTERP_MOTIF_11
  1439. #ifdef hpux            /* HPUX 7.0 uses Motif 1.0 -- name change to XmTextSetTopCharacter() occured in Motif patch 1.01 */
  1440.   return (cvfixnum((FIXTYPE) XmTextGetTopPosition(widget_id)));
  1441. #else /* not hpux */
  1442.   return (cvfixnum((FIXTYPE) XmTextGetTopCharacter(widget_id)));
  1443. #endif /* hpux */
  1444. #else /* WINTERP_MOTIF_11 */
  1445.   return (cvfixnum((FIXTYPE) XmTextGetTopCharacter(widget_id)));
  1446. #endif /* WINTERP_MOTIF_11 */
  1447. }
  1448.  
  1449.  
  1450. /*****************************************************************************
  1451.  * (send <text_widget> :SET_TOP_CHARACTER <top_position>)
  1452.  *
  1453.  * Note that this method is on XmText only; missing from XmTextField
  1454.  * void XmTextSetTopCharacter (Widget widget, XmTextPosition top_character);
  1455.  ****************************************************************************/
  1456. LVAL Xm_Text_Widget_Class_Method_SET_TOP_CHARACTER()
  1457. {
  1458.   LVAL self;
  1459.   XmTextPosition top_position;
  1460.   Widget widget_id;
  1461.  
  1462.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1463.   top_position = Get_XmTextPosition_Argument();
  1464.   xllastarg();
  1465.  
  1466. #ifndef WINTERP_MOTIF_11
  1467. #ifdef hpux            /* HPUX 7.0 uses Motif 1.0 -- name change to XmTextSetTopCharacter() occured in Motif patch 1.01 */
  1468.   XmTextSetTopPosition(widget_id, top_position);
  1469. #else /* hpux */
  1470.   XmTextSetTopCharacter(widget_id, top_position);
  1471. #endif /* hpux */
  1472. #else /* WINTERP_MOTIF_11 */
  1473.   XmTextSetTopCharacter(widget_id, top_position);
  1474. #endif /* WINTERP_MOTIF_11 */
  1475.  
  1476.   return (self);
  1477. }
  1478.  
  1479.  
  1480. /*****************************************************************************
  1481.  * (send <text_widget> :GET_INSERTION_POSITION)
  1482.  *
  1483.  * XmTextPosition XmTextGetInsertionPosition (Widget widget);
  1484.  * XmTextPosition XmTextFieldGetInsertionPosition (Widget widget);
  1485.  ****************************************************************************/
  1486. LVAL Xm_Text_Widget_Class_Method_GET_INSERTION_POSITION()
  1487. {
  1488.   LVAL self;
  1489.   Widget widget_id;
  1490.  
  1491.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1492.   xllastarg();
  1493.  
  1494.   return (cvfixnum((FIXTYPE) XmTextGetInsertionPosition(widget_id)));
  1495. }
  1496.  
  1497. #ifdef WINTERP_MOTIF_11
  1498. LVAL Xm_Text_Field_Widget_Class_Method_GET_INSERTION_POSITION()
  1499. {
  1500.   LVAL self;
  1501.   Widget widget_id;
  1502.  
  1503.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1504.   xllastarg();
  1505.  
  1506.   return (cvfixnum((FIXTYPE) XmTextFieldGetInsertionPosition(widget_id)));
  1507. }
  1508. #endif                /* WINTERP_MOTIF_11 */
  1509.  
  1510. #ifdef WINTERP_MOTIF_11
  1511. /*****************************************************************************
  1512.  * (send <text_widget> :GET_CURSOR_POSITION)
  1513.  *
  1514.  * XmTextPosition XmTextGetCursorPosition (Widget widget);
  1515.  * XmTextPosition XmTextFieldGetCursorPosition (Widget widget);
  1516.  ****************************************************************************/
  1517. LVAL Xm_Text_Widget_Class_Method_GET_CURSOR_POSITION()
  1518. {
  1519.   LVAL self;
  1520.   Widget widget_id;
  1521.  
  1522.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1523.   xllastarg();
  1524.  
  1525.   return (cvfixnum((FIXTYPE) XmTextGetCursorPosition(widget_id)));
  1526. }
  1527.  
  1528. LVAL Xm_Text_Field_Widget_Class_Method_GET_CURSOR_POSITION()
  1529. {
  1530.   LVAL self;
  1531.   Widget widget_id;
  1532.  
  1533.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1534.   xllastarg();
  1535.  
  1536.   return (cvfixnum((FIXTYPE) XmTextFieldGetCursorPosition(widget_id)));
  1537. }
  1538. #endif                /* WINTERP_MOTIF_11 */
  1539.  
  1540.  
  1541. /*****************************************************************************
  1542.  * (send <text_widget> :SET_INSERTION_POSITION <position>)
  1543.  *
  1544.  * void XmTextSetInsertionPosition (Widget widget, XmTextPosition position);
  1545.  * void XmTextFieldSetInsertionPosition (Widget widget, XmTextPosition position);
  1546.  ****************************************************************************/
  1547. LVAL Xm_Text_Widget_Class_Method_SET_INSERTION_POSITION()
  1548. {
  1549.   LVAL self;
  1550.   XmTextPosition insertion_position;
  1551.   Widget widget_id;
  1552.  
  1553.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1554.   insertion_position = Get_XmTextPosition_Argument();
  1555.   xllastarg();
  1556.  
  1557.   XmTextSetInsertionPosition(widget_id, insertion_position);
  1558.   return (self);
  1559. }
  1560.  
  1561. #ifdef WINTERP_MOTIF_11
  1562. LVAL Xm_Text_Field_Widget_Class_Method_SET_INSERTION_POSITION()
  1563. {
  1564.   LVAL self;
  1565.   XmTextPosition insertion_position;
  1566.   Widget widget_id;
  1567.  
  1568.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1569.   insertion_position = Get_XmTextPosition_Argument();
  1570.   xllastarg();
  1571.  
  1572.   XmTextFieldSetInsertionPosition(widget_id, insertion_position);
  1573.   return (self);
  1574. }
  1575. #endif                /* WINTERP_MOTIF_11 */
  1576.  
  1577.  
  1578. #ifdef WINTERP_MOTIF_11
  1579. /*****************************************************************************
  1580.  * (send <text_widget> :SET_CURSOR_POSITION <position>)
  1581.  *
  1582.  * void XmTextSetCursorPosition (Widget widget, XmTextPosition position);
  1583.  * void XmTextFieldSetCursorPosition (Widget widget, XmTextPosition position);
  1584.  ****************************************************************************/
  1585. LVAL Xm_Text_Widget_Class_Method_SET_CURSOR_POSITION()
  1586. {
  1587.   LVAL self;
  1588.   XmTextPosition insertion_position;
  1589.   Widget widget_id;
  1590.  
  1591.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1592.   insertion_position = Get_XmTextPosition_Argument();
  1593.   xllastarg();
  1594.  
  1595.   XmTextSetCursorPosition(widget_id, insertion_position);
  1596.   return (self);
  1597. }
  1598.  
  1599. LVAL Xm_Text_Field_Widget_Class_Method_SET_CURSOR_POSITION()
  1600. {
  1601.   LVAL self;
  1602.   XmTextPosition insertion_position;
  1603.   Widget widget_id;
  1604.  
  1605.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1606.   insertion_position = Get_XmTextPosition_Argument();
  1607.   xllastarg();
  1608.  
  1609.   XmTextFieldSetCursorPosition(widget_id, insertion_position);
  1610.   return (self);
  1611. }
  1612. #endif                /* WINTERP_MOTIF_11 */
  1613.  
  1614.  
  1615. /*****************************************************************************
  1616.  * (send <text_widget> :GET_SELECTION_POSITION)
  1617.  *
  1618.  * Boolean XmTextGetSelectionPosition (Widget widget, XmTextPosition *left, XmTextPosition *right);
  1619.  * Boolean XmTextFieldGetSelectionPosition (Widget widget, XmTextPosition *left, XmTextPosition *right);
  1620.  ****************************************************************************/
  1621. LVAL Xm_Text_Widget_Class_Method_GET_SELECTION_POSITION()
  1622. {
  1623.   LVAL self, lval_result, lval_left_pos, lval_right_pos;
  1624.   Widget widget_id;
  1625.   long left_pos, right_pos;
  1626.  
  1627.   /* protect some pointers */
  1628.   xlstkcheck(3);
  1629.   xlsave(lval_left_pos);
  1630.   xlsave(lval_right_pos);
  1631.   xlsave(lval_result);
  1632.  
  1633.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1634.   xllastarg();
  1635.  
  1636. #if (defined(WINTERP_MOTIF_11) || defined(hpux))
  1637.   if (XmTextGetSelectionPosition(widget_id, &left_pos, &right_pos)) {
  1638.     lval_left_pos = cvfixnum((FIXTYPE) left_pos);
  1639.     lval_right_pos = cvfixnum((FIXTYPE) right_pos);
  1640.     lval_result = cons(lval_left_pos, lval_right_pos);
  1641.   }
  1642.   else 
  1643.     lval_result = NIL;
  1644. #else
  1645.   /*
  1646.    * In HPUX 7.0's Motif 1.0, XmTextGetSelectionPosition() is defined... however
  1647.    * other manufacturers libXm (e.g. IBM AIX 3.1) don't export XmTextGetSelectionPosition().
  1648.    * In order to make WINTERP compile with the unknown Motif 1.0 libXm's "out there,
  1649.    * I've decided to only allow Motif 1.0 access to XmTextGetSelectionPosition() from HPUX.
  1650.    * If your Motif 1.0 dist supports this, then make sure the above #if expression becomes true.
  1651.    */
  1652.   xlfail("XmTextGetSelectionPosition() may not be defined on non-HPUX Motif 1.0.\nIf you know that it exists in your Motif installation, and you need to use\nthis method, you should recompile winterp after modifying src-server/wc_Text.c.");
  1653. #endif
  1654.  
  1655.   /* restore the stack */
  1656.   xlpopn(3);
  1657.  
  1658.   return (lval_result);
  1659. }
  1660.  
  1661. #ifdef WINTERP_MOTIF_11
  1662. LVAL Xm_Text_Field_Widget_Class_Method_GET_SELECTION_POSITION()
  1663. {
  1664.   LVAL self, lval_result, lval_left_pos, lval_right_pos;
  1665.   Widget widget_id;
  1666.   long left_pos, right_pos;
  1667.  
  1668.   /* protect some pointers */
  1669.   xlstkcheck(3);
  1670.   xlsave(lval_left_pos);
  1671.   xlsave(lval_right_pos);
  1672.   xlsave(lval_result);
  1673.  
  1674.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1675.   xllastarg();
  1676.  
  1677.   if (XmTextFieldGetSelectionPosition(widget_id, &left_pos, &right_pos)) {
  1678.     lval_left_pos = cvfixnum((FIXTYPE) left_pos);
  1679.     lval_right_pos = cvfixnum((FIXTYPE) right_pos);
  1680.     lval_result = cons(lval_left_pos, lval_right_pos);
  1681.   }
  1682.   else 
  1683.     lval_result = NIL;
  1684.  
  1685.   /* restore the stack */
  1686.   xlpopn(3);
  1687.  
  1688.   return (lval_result);
  1689. }
  1690. #endif                /* WINTERP_MOTIF_11 */
  1691.  
  1692.  
  1693. /*****************************************************************************
  1694.  * (send <text_widget> :XY_TO_POS <x> <y>)
  1695.  *
  1696.  * XmTextPosition XmTextXYToPos (Widget widget, Position x, Position y);
  1697.  * XmTextPosition XmTextFieldXYToPos (Widget widget, Position x, Position y);
  1698.  ****************************************************************************/
  1699. LVAL Xm_Text_Widget_Class_Method_XY_TO_POS()
  1700. {
  1701.   LVAL self;
  1702.   Position x, y;
  1703.   Widget widget_id;
  1704.  
  1705.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1706.   x = (Position) Get_Int_Argument((long) SHRT_MIN, (long) SHRT_MAX);
  1707.   y = (Position) Get_Int_Argument((long) SHRT_MIN, (long) SHRT_MAX);
  1708.   xllastarg();
  1709.  
  1710. #if (defined(WINTERP_MOTIF_11) || defined(hpux))
  1711.   return (cvfixnum((FIXTYPE) XmTextXYToPos(widget_id, x, y)));
  1712. #else
  1713.   /*
  1714.    * In HPUX 7.0's Motif 1.0,  XmTextXYToPos() is defined... however
  1715.    * other manufacturers libXm (e.g. IBM AIX 3.1) don't export  XmTextXYToPos().
  1716.    * In order to make WINTERP compile with the unknown Motif 1.0 libXm's "out there,
  1717.    * I've decided to only allow Motif 1.0 access to  XmTextXYToPos() from HPUX.
  1718.    * If your Motif 1.0 dist supports this, then make sure the above #if expression becomes true.
  1719.    */
  1720.   xlfail("XmTextXYToPos() may not be defined on non-HPUX Motif 1.0.\nIf you know that it exists in your Motif installation, and you need to use\nthis method, you should recompile winterp after modifying src-server/wc_Text.c.");
  1721.   return (NIL);
  1722. #endif
  1723. }
  1724.  
  1725. #ifdef WINTERP_MOTIF_11
  1726. LVAL Xm_Text_Field_Widget_Class_Method_XY_TO_POS()
  1727. {
  1728.   LVAL self;
  1729.   Position x, y;
  1730.   Widget widget_id;
  1731.  
  1732.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1733.   x = (Position) Get_Int_Argument((long) SHRT_MIN, (long) SHRT_MAX);
  1734.   y = (Position) Get_Int_Argument((long) SHRT_MIN, (long) SHRT_MAX);
  1735.   xllastarg();
  1736.  
  1737.   return (cvfixnum((FIXTYPE) XmTextFieldXYToPos(widget_id, x, y)));
  1738. }
  1739. #endif                /* WINTERP_MOTIF_11 */
  1740.  
  1741.  
  1742. /*****************************************************************************
  1743.  * (send <text_widget> :POS_TO_XY <position>)
  1744.  *
  1745.  * Boolean XmTextPosToXY (Widget widget, XmTextPosition position, Position *x, Position *y);
  1746.  * Boolean XmTextFieldPosToXY (Widget widget, XmTextPosition position, Position *x, Position *y);
  1747.  ****************************************************************************/
  1748. LVAL Xm_Text_Widget_Class_Method_POS_TO_XY()
  1749. {
  1750.   LVAL self, lval_result, lval_x, lval_y;
  1751.   Widget widget_id;
  1752.   XmTextPosition position;
  1753.   Position x, y;
  1754.  
  1755.   /* protect some pointers */
  1756.   xlstkcheck(3);
  1757.   xlsave(lval_x);
  1758.   xlsave(lval_y);
  1759.   xlsave(lval_result);
  1760.  
  1761.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1762.   position =  Get_XmTextPosition_Argument();
  1763.   xllastarg();
  1764.  
  1765. #if (defined(WINTERP_MOTIF_11) || defined(hpux))
  1766.   if (XmTextPosToXY(widget_id, position, &x, &y)) {
  1767.     lval_x = cvfixnum((FIXTYPE) x);
  1768.     lval_y = cvfixnum((FIXTYPE) y);
  1769.     lval_result = cons(lval_x, lval_y);
  1770.   }
  1771.   else 
  1772.     lval_result = NIL;
  1773. #else
  1774.   /*
  1775.    * In HPUX 7.0's Motif 1.0, XmTextPosToXY() is defined... however
  1776.    * other manufacturers libXm (e.g. IBM AIX 3.1) don't export  XmTextPosToXY().
  1777.    * In order to make WINTERP compile with the unknown Motif 1.0 libXm's "out there,
  1778.    * I've decided to only allow Motif 1.0 access to XmTextPosToXY() from HPUX.
  1779.    * If your Motif 1.0 dist supports this, then make sure the above #if expression becomes true.
  1780.    */
  1781.   xlfail("XmTextPosToXY() may not be defined on non-HPUX Motif 1.0.\nIf you know that it exists in your Motif installation, and you need to use\nthis method, you should recompile winterp after modifying src-server/wc_Text.c.");
  1782. #endif
  1783.  
  1784.   /* restore the stack */
  1785.   xlpopn(3);
  1786.  
  1787.   return (lval_result);
  1788. }
  1789.  
  1790. #ifdef WINTERP_MOTIF_11
  1791. LVAL Xm_Text_Field_Widget_Class_Method_POS_TO_XY()
  1792. {
  1793.   LVAL self, lval_result, lval_x, lval_y;
  1794.   Widget widget_id;
  1795.   XmTextPosition position;
  1796.   Position x, y;
  1797.  
  1798.   /* protect some pointers */
  1799.   xlstkcheck(3);
  1800.   xlsave(lval_x);
  1801.   xlsave(lval_y);
  1802.   xlsave(lval_result);
  1803.  
  1804.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1805.   position =  Get_XmTextPosition_Argument();
  1806.   xllastarg();
  1807.  
  1808.   if (XmTextFieldPosToXY(widget_id, position, &x, &y)) {
  1809.     lval_x = cvfixnum((FIXTYPE) x);
  1810.     lval_y = cvfixnum((FIXTYPE) y);
  1811.     lval_result = cons(lval_x, lval_y);
  1812.   }
  1813.   else 
  1814.     lval_result = NIL;
  1815.  
  1816.   /* restore the stack */
  1817.   xlpopn(3);
  1818.  
  1819.   return (lval_result);
  1820. }
  1821. #endif                /* WINTERP_MOTIF_11 */
  1822.  
  1823.  
  1824. /******************************************************************************
  1825.  * Ignore this one for now, since text sources are best set and programmed in C
  1826.  * This method is for XmText only.
  1827.  *
  1828.  * XmTextSource XmTextGetSource (Widget widget);
  1829.  ******************************************************************************/
  1830.  
  1831.  
  1832. /******************************************************************************
  1833.  * Ignore this one for now, since text sources are best set and programmed in C
  1834.  * This method is for XmText only.
  1835.  *
  1836.  * void XmTextSetSource (Widget widget,
  1837.  *                       XmTextSource source,
  1838.  *                       XmTextPosition top_character,
  1839.  *                       XmTextPosition cursor_position);
  1840.  ******************************************************************************/
  1841.  
  1842.  
  1843. /*****************************************************************************
  1844.  * (send <text_widget> :SHOW_POSITION <position>)
  1845.  *
  1846.  * void XmTextShowPosition (Widget widget, XmTextPosition position);
  1847.  * void XmTextFieldShowPosition (Widget widget, XmTextPosition position);
  1848.  ****************************************************************************/
  1849. LVAL Xm_Text_Widget_Class_Method_SHOW_POSITION()
  1850. {
  1851.   LVAL self;
  1852.   XmTextPosition position;
  1853.   Widget widget_id;
  1854.  
  1855.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1856.   position = Get_XmTextPosition_Argument();
  1857.   xllastarg();
  1858.  
  1859.   XmTextShowPosition(widget_id, position);
  1860.   return (self);
  1861. }
  1862.  
  1863. #ifdef WINTERP_MOTIF_11
  1864. LVAL Xm_Text_Field_Widget_Class_Method_SHOW_POSITION()
  1865. {
  1866.   LVAL self;
  1867.   XmTextPosition position;
  1868.   Widget widget_id;
  1869.  
  1870.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1871.   position = Get_XmTextPosition_Argument();
  1872.   xllastarg();
  1873.  
  1874.   XmTextFieldShowPosition(widget_id, position);
  1875.   return (self);
  1876. }
  1877. #endif                /* WINTERP_MOTIF_11 */
  1878.  
  1879.  
  1880. /*****************************************************************************
  1881.  * (send <text_widget> :SCROLL <n>)
  1882.  *
  1883.  * Note that this method is only defined on XmText widget, not def'd for
  1884.  * XmTextField widget.
  1885.  *
  1886.  * void XmTextScroll (Widget widget, int n);
  1887.  ****************************************************************************/
  1888. LVAL Xm_Text_Widget_Class_Method_SCROLL()
  1889. {
  1890.   LVAL self;
  1891.   Widget widget_id;
  1892.   int n;
  1893.  
  1894.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1895.   n = Get_Int_Argument((long) INT_MIN, (long) INT_MAX);
  1896.   xllastarg();
  1897.  
  1898. #if (defined(WINTERP_MOTIF_11) || defined(hpux))
  1899.   XmTextScroll(widget_id, n);
  1900. #else
  1901.   /*
  1902.    * In HPUX 7.0's Motif 1.0, XmTextScroll() is defined... however
  1903.    * other manufacturers libXm (e.g. IBM AIX 3.1) don't export XmTextScroll().
  1904.    * In order to make WINTERP compile with the unknown Motif 1.0 libXm's "out there,
  1905.    * I've decided to only allow Motif 1.0 access to XmTextScroll() from HPUX.
  1906.    * If your Motif 1.0 dist supports this, then make sure the above #if expression becomes true.
  1907.    */
  1908.   xlfail("XmTextScroll() may not be defined on non-HPUX Motif 1.0.\nIf you know that it exists in your Motif installation, and you need to use\nthis method, you should recompile winterp after modifying src-server/wc_Text.c.");
  1909. #endif
  1910.  
  1911.   return (self);
  1912. }
  1913.  
  1914.  
  1915. /*****************************************************************************
  1916.  * (send <text_widget> :DISABLE_REDISPLAY <loses-backingstore-p>)
  1917.  *
  1918.  * void XmTextDisableRedisplay(widget, losesbackingstore)
  1919.  * XmTextWidget widget;
  1920.  * Boolean losesbackingstore;
  1921.  ****************************************************************************/
  1922. LVAL Xm_Text_Widget_Class_Method_DISABLE_REDISPLAY()
  1923. {
  1924.   LVAL self, lval_losesbackingstore_p;
  1925.   Widget widget_id;
  1926.  
  1927.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1928.   lval_losesbackingstore_p = xlgetarg();
  1929.   xllastarg();
  1930.  
  1931. #ifndef WINTERP_MOTIF_11
  1932.   XmTextDisableRedisplay(widget_id, (lval_losesbackingstore_p) ? TRUE : FALSE);
  1933. #else
  1934.   _XmTextDisableRedisplay(widget_id, (lval_losesbackingstore_p) ? TRUE : FALSE);
  1935. #endif /* WINTERP_MOTIF_11 */
  1936.  
  1937.   return (self);
  1938. }
  1939.  
  1940. /*****************************************************************************
  1941.  * (send <text_widget> :ENABLE_REDISPLAY)
  1942.  *
  1943.  * void XmTextEnableRedisplay(widget)
  1944.  * XmTextWidget widget;
  1945.  ****************************************************************************/
  1946. LVAL Xm_Text_Widget_Class_Method_ENABLE_REDISPLAY()
  1947. {
  1948.   LVAL self;
  1949.   Widget widget_id;
  1950.  
  1951.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1952.   xllastarg();
  1953.  
  1954. #ifndef WINTERP_MOTIF_11
  1955.   XmTextEnableRedisplay(widget_id);
  1956. #else
  1957.   _XmTextEnableRedisplay(widget_id);
  1958. #endif /* WINTERP_MOTIF_11 */
  1959.  
  1960.   return (self);
  1961. }
  1962.  
  1963. #ifdef WINTERP_MOTIF_11
  1964. /*****************************************************************************
  1965.  * (send <text_widget> :GET_BASELINE)
  1966.  *      ====> Returns a FIXNUM value that indicates the x position of
  1967.  *            the first baseline in the Text widget.  The calculation
  1968.  *            takes into account the margin height, shadow thickness,
  1969.  *            highlight thickness, and font ascent of the first font in
  1970.  *            the fontlist.  In this calculation the x position of the top
  1971.  *            of the widget is 0.
  1972.  *
  1973.  * int XmTextGetBaseline (Widget widget);
  1974.  * int XmTextFieldGetBaseline (Widget widget);
  1975.  ****************************************************************************/
  1976. LVAL Xm_Text_Widget_Class_Method_GET_BASELINE()
  1977. {
  1978.   LVAL self;
  1979.   Widget widget_id;
  1980.  
  1981.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1982.   xllastarg();
  1983.  
  1984.   return (cvfixnum((FIXTYPE) XmTextGetBaseline(widget_id)));
  1985. }
  1986.  
  1987. LVAL Xm_Text_Field_Widget_Class_Method_GET_BASELINE()
  1988. {
  1989.   LVAL self;
  1990.   Widget widget_id;
  1991.  
  1992.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  1993.   xllastarg();
  1994.  
  1995.   return (cvfixnum((FIXTYPE) XmTextFieldGetBaseline(widget_id)));
  1996. }
  1997. #endif                /* WINTERP_MOTIF_11 */
  1998.  
  1999.  
  2000. /******************************************************************************
  2001.  *
  2002.  ******************************************************************************/
  2003. Wc_Text_Init()
  2004. {
  2005.   LVAL o_XM_TEXT_WIDGET_CLASS;
  2006. #ifdef WINTERP_MOTIF_11
  2007.   LVAL o_XM_TEXT_FIELD_WIDGET_CLASS;
  2008. #endif                /* WINTERP_MOTIF_11 */
  2009.   extern LVAL Wcls_Create_Subclass_Of_WIDGET_CLASS(); /* w_classes.c */
  2010.   extern      xladdmsg();    /* from xlobj.c */
  2011.  
  2012.   o_XM_TEXT_WIDGET_CLASS =
  2013.     Wcls_Create_Subclass_Of_WIDGET_CLASS("XM_TEXT_WIDGET_CLASS",
  2014.                      xmTextWidgetClass);
  2015. #ifdef WINTERP_MOTIF_11
  2016.   o_XM_TEXT_FIELD_WIDGET_CLASS =
  2017.     Wcls_Create_Subclass_Of_WIDGET_CLASS("XM_TEXT_FIELD_WIDGET_CLASS",
  2018.                      xmTextFieldWidgetClass);
  2019. #endif                /* WINTERP_MOTIF_11 */
  2020.  
  2021.   /*
  2022.    * a special :isnew method on XM_TEXT_WIDGET_CLASS  allows for the creation of
  2023.    * this widget inside a scrolled window if the submessage keyword :scrolled
  2024.    * is given ...
  2025.    */
  2026.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":ISNEW", 
  2027.        FTAB_Xm_Text_Widget_Class_Method_ISNEW);
  2028. #ifdef WINTERP_MOTIF_11
  2029.   /*
  2030.    * Note that XM_TEXT_FIELD_WIDGET_CLASS does not define its own :ISNEW method.
  2031.    * XM_TEXT_FIELD_WIDGET_CLASS uses the default instance initializer in
  2032.    * <WIDGET_CLASS>.
  2033.    */
  2034. #endif                /* WINTERP_MOTIF_11 */
  2035.  
  2036. #ifdef WINTERP_MOTIF_11
  2037.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":PARENT",
  2038.            FTAB_Xm_Text_Widget_Class_Method_PARENT);
  2039. #endif                /* WINTERP_MOTIF_11 */
  2040.  
  2041.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":ADD_CALLBACK",
  2042.            FTAB_Xm_Text_Widget_Class_Method_ADD_CALLBACK);
  2043. #ifdef WINTERP_MOTIF_11
  2044.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":ADD_CALLBACK",
  2045.            FTAB_Xm_Text_Widget_Class_Method_ADD_CALLBACK);
  2046. #endif                /* WINTERP_MOTIF_11 */
  2047.  
  2048.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":SET_CALLBACK",
  2049.            FTAB_Xm_Text_Widget_Class_Method_SET_CALLBACK);
  2050. #ifdef WINTERP_MOTIF_11
  2051.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":SET_CALLBACK",
  2052.            FTAB_Xm_Text_Widget_Class_Method_SET_CALLBACK);
  2053. #endif                /* WINTERP_MOTIF_11 */
  2054.  
  2055. #ifdef WINTERP_MOTIF_11
  2056.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":SET_HIGHLIGHT",
  2057.            FTAB_Xm_Text_Widget_Class_Method_SET_HIGHLIGHT);
  2058.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":SET_HIGHLIGHT",
  2059.            FTAB_Xm_Text_Field_Widget_Class_Method_SET_HIGHLIGHT);
  2060. #endif                /* WINTERP_MOTIF_11 */
  2061.  
  2062.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":GET_STRING", 
  2063.        FTAB_Xm_Text_Widget_Class_Method_GET_STRING);
  2064. #ifdef WINTERP_MOTIF_11
  2065.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":GET_STRING", 
  2066.        FTAB_Xm_Text_Field_Widget_Class_Method_GET_STRING);
  2067. #endif                /* WINTERP_MOTIF_11 */
  2068.  
  2069.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":GET_LAST_POSITION",
  2070.        FTAB_Xm_Text_Widget_Class_Method_GET_LAST_POSITION);
  2071. #ifdef WINTERP_MOTIF_11
  2072.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":GET_LAST_POSITION",
  2073.        FTAB_Xm_Text_Field_Widget_Class_Method_GET_LAST_POSITION);
  2074. #endif                /* WINTERP_MOTIF_11 */
  2075.  
  2076.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":SET_STRING", 
  2077.        FTAB_Xm_Text_Widget_Class_Method_SET_STRING);
  2078. #ifdef WINTERP_MOTIF_11
  2079.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":SET_STRING", 
  2080.        FTAB_Xm_Text_Field_Widget_Class_Method_SET_STRING);
  2081. #endif                /* WINTERP_MOTIF_11 */
  2082.  
  2083.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":REPLACE",
  2084.        FTAB_Xm_Text_Widget_Class_Method_REPLACE);
  2085. #ifdef WINTERP_MOTIF_11
  2086.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":REPLACE",
  2087.        FTAB_Xm_Text_Field_Widget_Class_Method_REPLACE);
  2088. #endif                /* WINTERP_MOTIF_11 */
  2089.  
  2090. #ifdef WINTERP_MOTIF_11
  2091.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":INSERT",
  2092.            FTAB_Xm_Text_Widget_Class_Method_INSERT);
  2093.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":INSERT",
  2094.            FTAB_Xm_Text_Field_Widget_Class_Method_INSERT);
  2095. #endif                /* WINTERP_MOTIF_11 */
  2096.  
  2097. #ifdef WINTERP_MOTIF_11
  2098.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":SET_ADD_MODE",
  2099.            FTAB_Xm_Text_Widget_Class_Method_SET_ADD_MODE);
  2100.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":SET_ADD_MODE",
  2101.            FTAB_Xm_Text_Field_Widget_Class_Method_SET_ADD_MODE);
  2102. #endif                /* WINTERP_MOTIF_11 */
  2103.  
  2104. #ifdef WINTERP_MOTIF_11
  2105.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":GET_ADD_MODE",
  2106.            FTAB_Xm_Text_Widget_Class_Method_GET_ADD_MODE);
  2107.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":GET_ADD_MODE",
  2108.            FTAB_Xm_Text_Field_Widget_Class_Method_GET_ADD_MODE);
  2109. #endif                /* WINTERP_MOTIF_11 */
  2110.  
  2111.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":GET_EDITABLE",
  2112.        FTAB_Xm_Text_Widget_Class_Method_GET_EDITABLE);
  2113. #ifdef WINTERP_MOTIF_11
  2114.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":GET_EDITABLE",
  2115.        FTAB_Xm_Text_Field_Widget_Class_Method_GET_EDITABLE);
  2116. #endif                /* WINTERP_MOTIF_11 */
  2117.  
  2118.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":SET_EDITABLE",
  2119.        FTAB_Xm_Text_Widget_Class_Method_SET_EDITABLE);
  2120. #ifdef WINTERP_MOTIF_11
  2121.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":SET_EDITABLE",
  2122.        FTAB_Xm_Text_Field_Widget_Class_Method_SET_EDITABLE);
  2123. #endif                /* WINTERP_MOTIF_11 */
  2124.  
  2125.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":GET_MAX_LENGTH",
  2126.        FTAB_Xm_Text_Widget_Class_Method_GET_MAX_LENGTH);
  2127. #ifdef WINTERP_MOTIF_11
  2128.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":GET_MAX_LENGTH",
  2129.        FTAB_Xm_Text_Field_Widget_Class_Method_GET_MAX_LENGTH);
  2130. #endif                /* WINTERP_MOTIF_11 */
  2131.  
  2132.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":SET_MAX_LENGTH",
  2133.        FTAB_Xm_Text_Widget_Class_Method_SET_MAX_LENGTH);
  2134. #ifdef WINTERP_MOTIF_11
  2135.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":SET_MAX_LENGTH",
  2136.        FTAB_Xm_Text_Field_Widget_Class_Method_SET_MAX_LENGTH);
  2137. #endif                /* WINTERP_MOTIF_11 */
  2138.  
  2139. #ifdef WINTERP_MOTIF_11
  2140.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":REMOVE",
  2141.        FTAB_Xm_Text_Widget_Class_Method_REMOVE);
  2142.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":REMOVE",
  2143.        FTAB_Xm_Text_Field_Widget_Class_Method_REMOVE);
  2144. #endif                /* WINTERP_MOTIF_11 */
  2145.  
  2146. #ifdef WINTERP_MOTIF_11
  2147.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":COPY",
  2148.        FTAB_Xm_Text_Widget_Class_Method_COPY);
  2149.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":COPY",
  2150.        FTAB_Xm_Text_Field_Widget_Class_Method_COPY);
  2151. #endif                /* WINTERP_MOTIF_11 */
  2152.  
  2153. #ifdef WINTERP_MOTIF_11
  2154.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":CUT",
  2155.        FTAB_Xm_Text_Widget_Class_Method_CUT);
  2156.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":CUT",
  2157.        FTAB_Xm_Text_Field_Widget_Class_Method_CUT);
  2158. #endif                /* WINTERP_MOTIF_11 */
  2159.  
  2160. #ifdef WINTERP_MOTIF_11
  2161.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":PASTE",
  2162.        FTAB_Xm_Text_Widget_Class_Method_PASTE);
  2163.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":PASTE",
  2164.        FTAB_Xm_Text_Field_Widget_Class_Method_PASTE);
  2165. #endif                /* WINTERP_MOTIF_11 */
  2166.  
  2167.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":GET_SELECTION",
  2168.        FTAB_Xm_Text_Widget_Class_Method_GET_SELECTION);
  2169. #ifdef WINTERP_MOTIF_11
  2170.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":GET_SELECTION",
  2171.        FTAB_Xm_Text_Field_Widget_Class_Method_GET_SELECTION);
  2172. #endif                /* WINTERP_MOTIF_11 */
  2173.  
  2174.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":SET_SELECTION",
  2175.        FTAB_Xm_Text_Widget_Class_Method_SET_SELECTION);
  2176. #ifdef WINTERP_MOTIF_11
  2177.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":SET_SELECTION",
  2178.        FTAB_Xm_Text_Field_Widget_Class_Method_SET_SELECTION);
  2179. #endif                /* WINTERP_MOTIF_11 */
  2180.  
  2181.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":CLEAR_SELECTION",
  2182.        FTAB_Xm_Text_Widget_Class_Method_CLEAR_SELECTION);
  2183. #ifdef WINTERP_MOTIF_11
  2184.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":CLEAR_SELECTION",
  2185.        FTAB_Xm_Text_Field_Widget_Class_Method_CLEAR_SELECTION);
  2186. #endif                /* WINTERP_MOTIF_11 */
  2187.  
  2188.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":GET_TOP_CHARACTER",
  2189.        FTAB_Xm_Text_Widget_Class_Method_GET_TOP_CHARACTER);
  2190.  
  2191.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":SET_TOP_CHARACTER",
  2192.        FTAB_Xm_Text_Widget_Class_Method_SET_TOP_CHARACTER);
  2193.  
  2194.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":GET_INSERTION_POSITION",
  2195.        FTAB_Xm_Text_Widget_Class_Method_GET_INSERTION_POSITION);
  2196. #ifdef WINTERP_MOTIF_11
  2197.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":GET_INSERTION_POSITION",
  2198.        FTAB_Xm_Text_Field_Widget_Class_Method_GET_INSERTION_POSITION);
  2199. #endif                /* WINTERP_MOTIF_11 */
  2200.  
  2201. #ifdef WINTERP_MOTIF_11
  2202.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":GET_CURSOR_POSITION",
  2203.        FTAB_Xm_Text_Widget_Class_Method_GET_CURSOR_POSITION);
  2204.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":GET_CURSOR_POSITION",
  2205.        FTAB_Xm_Text_Field_Widget_Class_Method_GET_CURSOR_POSITION);
  2206. #endif                /* WINTERP_MOTIF_11 */
  2207.  
  2208.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":SET_INSERTION_POSITION",
  2209.        FTAB_Xm_Text_Widget_Class_Method_SET_INSERTION_POSITION);
  2210. #ifdef WINTERP_MOTIF_11
  2211.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":SET_INSERTION_POSITION",
  2212.        FTAB_Xm_Text_Field_Widget_Class_Method_SET_INSERTION_POSITION);
  2213. #endif                /* WINTERP_MOTIF_11 */
  2214.  
  2215. #ifdef WINTERP_MOTIF_11
  2216.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":SET_CURSOR_POSITION",
  2217.        FTAB_Xm_Text_Widget_Class_Method_SET_CURSOR_POSITION);
  2218.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":SET_CURSOR_POSITION",
  2219.        FTAB_Xm_Text_Field_Widget_Class_Method_SET_CURSOR_POSITION);
  2220. #endif                /* WINTERP_MOTIF_11 */
  2221.  
  2222.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":GET_SELECTION_POSITION",
  2223.        FTAB_Xm_Text_Widget_Class_Method_GET_SELECTION_POSITION);
  2224. #ifdef WINTERP_MOTIF_11
  2225.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":GET_SELECTION_POSITION",
  2226.        FTAB_Xm_Text_Field_Widget_Class_Method_GET_SELECTION_POSITION);
  2227. #endif                /* WINTERP_MOTIF_11 */
  2228.  
  2229.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":XY_TO_POS",
  2230.        FTAB_Xm_Text_Widget_Class_Method_XY_TO_POS);
  2231. #ifdef WINTERP_MOTIF_11
  2232.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":XY_TO_POS",
  2233.        FTAB_Xm_Text_Field_Widget_Class_Method_XY_TO_POS);
  2234. #endif                /* WINTERP_MOTIF_11 */
  2235.  
  2236.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":POS_TO_XY",
  2237.        FTAB_Xm_Text_Widget_Class_Method_POS_TO_XY);
  2238. #ifdef WINTERP_MOTIF_11
  2239.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":POS_TO_XY",
  2240.        FTAB_Xm_Text_Field_Widget_Class_Method_POS_TO_XY);
  2241. #endif                /* WINTERP_MOTIF_11 */
  2242.  
  2243.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":SHOW_POSITION",
  2244.        FTAB_Xm_Text_Widget_Class_Method_SHOW_POSITION);
  2245. #ifdef WINTERP_MOTIF_11
  2246.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":SHOW_POSITION",
  2247.        FTAB_Xm_Text_Field_Widget_Class_Method_SHOW_POSITION);
  2248. #endif                /* WINTERP_MOTIF_11 */
  2249.  
  2250.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":SCROLL",
  2251.        FTAB_Xm_Text_Widget_Class_Method_SCROLL);
  2252.  
  2253.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":DISABLE_REDISPLAY",
  2254.        FTAB_Xm_Text_Widget_Class_Method_DISABLE_REDISPLAY);
  2255.  
  2256.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":ENABLE_REDISPLAY",
  2257.        FTAB_Xm_Text_Widget_Class_Method_ENABLE_REDISPLAY);
  2258.  
  2259. #ifdef WINTERP_MOTIF_11
  2260.   xladdmsg(o_XM_TEXT_WIDGET_CLASS, ":GET_BASELINE",
  2261.        FTAB_Xm_Text_Widget_Class_Method_GET_BASELINE);
  2262.   xladdmsg(o_XM_TEXT_FIELD_WIDGET_CLASS, ":GET_BASELINE",
  2263.        FTAB_Xm_Text_Field_Widget_Class_Method_GET_BASELINE);
  2264. #endif                /* WINTERP_MOTIF_11 */
  2265.  
  2266.  
  2267.   /* 
  2268.    * Set up symbols used in :ADD_CALLBACK and :SET_CALLBACK 
  2269.    * Lexical_Bindings_For_XmTextVerifyCallbackStruct().
  2270.    */
  2271.   s_CALLBACK_DOIT = xlenter("CALLBACK_DOIT");
  2272.   s_CALLBACK_CUR_INSERT = xlenter("CALLBACK_CUR_INSERT");
  2273.   s_CALLBACK_NEW_INSERT = xlenter("CALLBACK_NEW_INSERT");
  2274.   s_CALLBACK_START_POS = xlenter("CALLBACK_START_POS");
  2275.   s_CALLBACK_END_POS = xlenter("CALLBACK_END_POS");
  2276.   s_CALLBACK_TEXT = xlenter("CALLBACK_TEXT");
  2277.  
  2278. #ifdef WINTERP_MOTIF_11
  2279.   /* 
  2280.    * Set up symbols used in Xm_Text_Widget_Class_Method_SET_HIGHLIGHT()
  2281.    * and Xm_Text_Field_Widget_Class_Method_SET_HIGHLIGHT()
  2282.    */
  2283.   s_HIGHLIGHT_NORMAL = xlenter(":HIGHLIGHT_NORMAL");
  2284.   s_HIGHLIGHT_SELECTED = xlenter(":HIGHLIGHT_SELECTED");
  2285.   s_HIGHLIGHT_SECONDARY_SELECTED = xlenter(":HIGHLIGHT_SECONDARY_SELECTED");
  2286. #endif                /* WINTERP_MOTIF_11 */
  2287. }
  2288.